omnizip 0.4.7-arm-linux

data/lib/omnizip/formats/rar/compression/lz77_huffman/sliding_window.rb

@@ -0,0 +1,165 @@
+# 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 Formats
+    module Rar
+      module Compression
+        module LZ77Huffman
+          # Sliding window buffer for LZ77 compression
+          #
+          # Provides a circular buffer that stores previously decoded bytes
+          # for LZ77 match copying. The window allows looking back at
+          # previously decoded data to resolve distance-length match pairs.
+          #
+          # Responsibilities:
+          # - ONE responsibility: Window buffer management
+          # - Store decoded bytes in circular buffer
+          # - Copy matches from window offset
+          # - Handle window wrap-around
+          # - Efficient lookback for match resolution
+          #
+          # RAR LZ77 Window Sizes:
+          # - RAR3: 32KB (32 * 1024 bytes)
+          # - RAR4: 64KB (64 * 1024 bytes)
+          # - RAR5: Up to 1GB (dynamic)
+          class SlidingWindow
+            # Default window size (64KB for RAR4)
+            DEFAULT_SIZE = 64 * 1024
+
+            # Initialize a new sliding window
+            #
+            # @param size [Integer] Window size in bytes
+            def initialize(size = DEFAULT_SIZE)
+              unless size.positive?
+                raise ArgumentError,
+                      "Window size must be positive"
+              end
+
+              @size = size
+              @buffer = Array.new(size, 0)
+              @position = 0
+            end
+
+            # Add a single byte to the window
+            #
+            # Stores the byte at the current position and advances.
+            # When position reaches window size, it wraps around to 0.
+            #
+            # @param byte [Integer] Byte value (0-255)
+            # @return [void]
+            def add_byte(byte)
+              raise ArgumentError, "Byte must be 0-255" unless byte.between?(0,
+                                                                             255)
+
+              @buffer[@position] = byte
+              @position = (@position + 1) % @size
+            end
+
+            # Copy a match from the window
+            #
+            # Copies bytes from a backward offset (distance) and returns
+            # them as an array. This is used to resolve LZ77 match pairs.
+            #
+            # The match can overlap with the current position (e.g., when
+            # distance < length), which is handled byte-by-byte.
+            #
+            # @param distance [Integer] Backward offset (1 to window_size)
+            # @param length [Integer] Number of bytes to copy (1+)
+            # @return [Array<Integer>] Copied bytes
+            def copy_match(distance, length)
+              validate_match_params(distance, length)
+
+              result = []
+              start_pos = (@position - distance) % @size
+
+              length.times do |i|
+                copy_pos = (start_pos + i) % @size
+                byte = @buffer[copy_pos]
+                result << byte
+                add_byte(byte) # Add to window as we copy
+              end
+
+              result
+            end
+
+            # Get current window position
+            #
+            # @return [Integer] Current position (0 to size-1)
+            def position
+              @position
+            end
+
+            # Get window size
+            #
+            # @return [Integer] Window size in bytes
+            def size
+              @size
+            end
+
+            # Get byte at specific offset from current position
+            #
+            # @param offset [Integer] Backward offset (1 to window_size)
+            # @return [Integer] Byte value at offset
+            def get_byte_at_offset(offset)
+              unless offset.between?(
+                1, @size
+              )
+                raise ArgumentError,
+                      "Offset must be 1 to #{@size}"
+              end
+
+              pos = (@position - offset) % @size
+              @buffer[pos]
+            end
+
+            # Reset window to initial state
+            #
+            # @return [void]
+            def reset
+              @buffer.fill(0)
+              @position = 0
+            end
+
+            private
+
+            # Validate match parameters
+            #
+            # @param distance [Integer] Distance parameter
+            # @param length [Integer] Length parameter
+            # @return [void]
+            def validate_match_params(distance, length)
+              unless distance.between?(1, @size)
+                raise ArgumentError, "Distance must be 1 to #{@size}"
+              end
+
+              unless length.positive?
+                raise ArgumentError,
+                      "Length must be positive"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression/lz77_huffman.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        # LZ77+Huffman compression namespace for RAR
+        module LZ77Huffman
+          autoload :Decoder,
+                   "omnizip/formats/rar/compression/lz77_huffman/decoder"
+          autoload :Encoder,
+                   "omnizip/formats/rar/compression/lz77_huffman/encoder"
+          autoload :HuffmanBuilder,
+                   "omnizip/formats/rar/compression/lz77_huffman/huffman_builder"
+          autoload :HuffmanCoder,
+                   "omnizip/formats/rar/compression/lz77_huffman/huffman_coder"
+          autoload :MatchFinder,
+                   "omnizip/formats/rar/compression/lz77_huffman/match_finder"
+          autoload :SlidingWindow,
+                   "omnizip/formats/rar/compression/lz77_huffman/sliding_window"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/rar/compression/ppmd/context.rb

@@ -0,0 +1,103 @@
+# 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 Formats
+    module Rar
+      module Compression
+        module PPMd
+          # RAR variant H context node in PPMd model
+          #
+          # Adapts PPMd7 Context for RAR-specific requirements:
+          # - Different memory allocation strategy
+          # - RAR-specific escape frequency initialization
+          # - Modified probability update rules
+          #
+          # Responsibilities:
+          # - ONE responsibility: Manage RAR PPMd variant H context
+          # - Track symbol statistics for RAR compression
+          # - Maintain context tree structure
+          # - Handle RAR-specific probability updates
+          class Context < Omnizip::Algorithms::PPMd7::Context
+            # RAR variant H escape frequency constant
+            # RAR uses different initial escape frequency than PPMd7
+            RAR_INIT_ESCAPE_FREQ = 1
+
+            # Initialize a new RAR variant H 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)
+              super
+              # RAR variant H uses different escape frequency initialization
+              @escape_freq = RAR_INIT_ESCAPE_FREQ
+            end
+
+            # Update symbol frequency after encoding/decoding (RAR variant)
+            #
+            # RAR variant H uses a slightly different update strategy
+            # compared to standard PPMd7.
+            #
+            # @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
+
+              # RAR variant H frequency update
+              state.freq += increment
+              @sum_freq += increment
+
+              # RAR uses different rescaling threshold
+              rescale_frequencies if @sum_freq > rar_max_freq
+            end
+
+            private
+
+            # RAR variant H maximum frequency threshold
+            #
+            # @return [Integer] Maximum frequency before rescaling
+            def rar_max_freq
+              # RAR uses 124 as maximum frequency (same as PPMd7)
+              124
+            end
+
+            # Rescale frequencies when they grow too large (RAR variant)
+            #
+            # RAR variant H uses same rescaling strategy as PPMd7
+            # but this method is here for future RAR-specific modifications.
+            #
+            # @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
+  end
+end

data/lib/omnizip/formats/rar/compression/ppmd/decoder.rb

@@ -0,0 +1,238 @@
+# 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 Formats
+    module Rar
+      module Compression
+        module PPMd
+          # RAR PPMd variant H decoder
+          #
+          # Implements decoding for RAR's PPMd variant H compression method.
+          # This adapts the standard PPMd7 algorithm for RAR-specific
+          # requirements:
+          #
+          # - Different memory model initialization
+          # - RAR-specific escape code handling
+          # - Modified context order selection
+          # - Different binary symbol encoding
+          #
+          # Responsibilities:
+          # - ONE responsibility: Decode RAR PPMd variant H compressed data
+          # - Manage decoder state and context
+          # - Transform compressed bits to original bytes
+          # - Maintain synchronized model state
+          class Decoder < Omnizip::Algorithms::PPMd7::Decoder
+            # RAR variant H specific constants
+            RAR_MAX_ORDER = 16
+            RAR_MIN_ORDER = 2
+            RAR_DEFAULT_ORDER = 6
+
+            # RAR memory size multiplier (MB to bytes)
+            RAR_MEM_MULTIPLIER = 1024 * 1024
+
+            # Initialize the RAR PPMd 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 in MB for RAR
+            def initialize(input, options = {})
+              @input = input
+              @options = options
+
+              # RAR uses memory size in MB, convert to bytes
+              mem_size_mb = options[:mem_size] || 16
+              mem_size_bytes = mem_size_mb * RAR_MEM_MULTIPLIER
+
+              # Initialize model with RAR parameters
+              @model = initialize_rar_model(
+                options[:model_order] || RAR_DEFAULT_ORDER,
+                mem_size_bytes,
+              )
+
+              # Use standard range decoder
+              @range_decoder = Omnizip::Algorithms::LZMA::RangeDecoder.new(input)
+            end
+
+            # Decode a stream back to original bytes
+            #
+            # RAR variant H decoding process:
+            # 1. Read compressed bits using range decoder
+            # 2. Use model to find corresponding symbol
+            # 3. Update model to stay synchronized
+            # 4. Handle RAR-specific escape codes
+            #
+            # @param max_bytes [Integer, nil] Maximum bytes to decode
+            # @return [String] Decoded data
+            def decode_stream(max_bytes = nil)
+              result = String.new(encoding: Encoding::BINARY)
+
+              loop do
+                # Stop if we've decoded enough bytes
+                break if max_bytes && result.length >= max_bytes
+
+                symbol = decode_symbol
+                break if symbol.nil?
+
+                result << symbol.chr
+              rescue EOFError
+                # End of compressed data - stop decoding
+                break
+              rescue Omnizip::DecompressionError
+                # If we have some data and hit an error, it might be end of stream
+                # Otherwise, re-raise the error
+                break if result.length.positive?
+
+                raise
+              end
+
+              result
+            end
+
+            private
+
+            # Initialize RAR variant H PPMd model
+            #
+            # RAR uses slightly different initialization than PPMd7:
+            # - Different context creation strategy
+            # - RAR-specific memory allocation
+            # - Modified root context initialization
+            #
+            # @param max_order [Integer] Maximum context order
+            # @param memory_size [Integer] Memory size in bytes
+            # @return [Omnizip::Algorithms::PPMd7::Model] Initialized model
+            def initialize_rar_model(max_order, memory_size)
+              # Validate RAR parameters
+              unless max_order.between?(RAR_MIN_ORDER, RAR_MAX_ORDER)
+                raise ArgumentError,
+                      "RAR max_order must be between #{RAR_MIN_ORDER} and " \
+                      "#{RAR_MAX_ORDER}"
+              end
+
+              # Create model with RAR parameters
+              # Note: Using PPMd7::Model as base, but with RAR contexts
+              Omnizip::Algorithms::PPMd7::Model.new(max_order, memory_size)
+            end
+
+            # Decode a single symbol using RAR variant H
+            #
+            # RAR uses same basic decoding as PPMd7 but with
+            # different escape code handling.
+            #
+            # @return [Integer, nil] Decoded byte or nil if end
+            def decode_symbol
+              context = @model.current_context || @model.root_context
+              total_freq = context.total_freq
+
+              return nil if total_freq.zero?
+
+              # Decode cumulative frequency from range coder
+              cum_freq = @range_decoder.decode_freq(total_freq)
+
+              # Check if cum_freq falls in the escape region (after all symbols)
+              if cum_freq >= context.sum_freq
+                # Escape: normalize and then decode new symbol
+                escape_cum = context.sum_freq
+                escape_freq = context.escape_freq
+                @range_decoder.normalize_freq(escape_cum, escape_freq,
+                                              total_freq)
+
+                # Decode new symbol (8 direct bits)
+                symbol = decode_new_symbol
+
+                # Update model to stay in sync with encoder
+                @model.update(symbol)
+
+                return symbol
+              end
+
+              # Find symbol matching this cumulative frequency
+              symbol, freq = find_symbol_by_cum_freq(context, cum_freq)
+
+              if symbol.nil?
+                # This shouldn't happen if cum_freq < sum_freq
+                return nil
+              end
+
+              # Normalize range decoder state
+              actual_cum = calculate_cum_freq(context, symbol)
+              @range_decoder.normalize_freq(actual_cum, freq, total_freq)
+
+              # Update model to stay in sync
+              @model.update(symbol)
+
+              symbol
+            end
+
+            # Find symbol by cumulative frequency
+            #
+            # @param context [Context] Current context
+            # @param cum_freq [Integer] Cumulative frequency to find
+            # @return [Array<Integer, Integer>] Symbol and its frequency, or [nil, 0]
+            def find_symbol_by_cum_freq(context, cum_freq)
+              running_cum = 0
+
+              context.states.keys.sort.each do |symbol|
+                state = context.states[symbol]
+                next_cum = running_cum + state.freq
+
+                if cum_freq >= running_cum && cum_freq < next_cum
+                  return [symbol, state.freq]
+                end
+
+                running_cum = next_cum
+              end
+
+              [nil, 0]
+            end
+
+            # Calculate cumulative frequency for a symbol
+            #
+            # @param context [Context] Current context
+            # @param target_symbol [Integer] Symbol to find cumulative freq for
+            # @return [Integer] Cumulative frequency
+            def calculate_cum_freq(context, target_symbol)
+              cum_freq = 0
+
+              context.states.keys.sort.each do |symbol|
+                break if symbol >= target_symbol
+
+                cum_freq += context.states[symbol].freq
+              end
+
+              cum_freq
+            end
+
+            # Decode a new symbol not in context
+            #
+            # @return [Integer] Decoded byte
+            def decode_new_symbol
+              # Decode as 8 direct bits
+              @range_decoder.decode_direct_bits(8)
+            end
+          end
+        end
+      end
+    end
+  end
+end