omnizip 0.4.7-x86_64-linux

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

@@ -0,0 +1,180 @@
+# 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
+        # Bit-level I/O stream for RAR compression algorithms
+        #
+        # Provides methods to read and write individual bits from byte streams.
+        # This is a shared utility used by PPMd, LZ77+Huffman, and other RAR
+        # compression algorithms that need bit-level access.
+        #
+        # Responsibilities:
+        # - ONE responsibility: Bit-level I/O operations
+        # - Read bits from byte stream
+        # - Write bits to byte stream
+        # - Manage bit buffer and byte alignment
+        class BitStream
+          # Initialize a new bit stream
+          #
+          # @param io [IO] The underlying byte stream
+          # @param mode [Symbol] :read or :write
+          def initialize(io, mode = :read)
+            @io = io
+            @mode = mode
+            @buffer = 0
+            @bits_in_buffer = 0
+          end
+
+          # Read specified number of bits
+          #
+          # @param count [Integer] Number of bits to read (1-32)
+          # @return [Integer] The bits read as an integer
+          def read_bits(count)
+            unless @mode == :read
+              raise ArgumentError,
+                    "Can only read in read mode"
+            end
+            raise ArgumentError, "Count must be 1-32" unless count.between?(1,
+                                                                            32)
+
+            result = 0
+
+            count.times do
+              result = (result << 1) | read_bit
+            end
+
+            result
+          end
+
+          # Read a single bit
+          #
+          # @return [Integer] 0 or 1
+          def read_bit
+            unless @mode == :read
+              raise ArgumentError,
+                    "Can only read in read mode"
+            end
+
+            if @bits_in_buffer.zero?
+              fill_buffer
+            end
+
+            @bits_in_buffer -= 1
+            (@buffer >> @bits_in_buffer) & 1
+          end
+
+          # Write specified number of bits
+          #
+          # @param value [Integer] The value to write
+          # @param count [Integer] Number of bits to write (1-32)
+          # @return [void]
+          def write_bits(value, count)
+            unless @mode == :write
+              raise ArgumentError,
+                    "Can only write in write mode"
+            end
+            raise ArgumentError, "Count must be 1-32" unless count.between?(1,
+                                                                            32)
+
+            count.times do |i|
+              bit = (value >> (count - 1 - i)) & 1
+              write_bit(bit)
+            end
+          end
+
+          # Write a single bit
+          #
+          # @param bit [Integer] 0 or 1
+          # @return [void]
+          def write_bit(bit)
+            unless @mode == :write
+              raise ArgumentError,
+                    "Can only write in write mode"
+            end
+
+            @buffer = (@buffer << 1) | (bit & 1)
+            @bits_in_buffer += 1
+
+            flush_buffer if @bits_in_buffer == 8
+          end
+
+          # Align to byte boundary (read mode)
+          #
+          # @return [void]
+          def align_to_byte
+            return unless @mode == :read
+
+            @bits_in_buffer = 0
+            @buffer = 0
+          end
+
+          # Flush any remaining bits (write mode)
+          #
+          # @return [void]
+          def flush
+            return unless @mode == :write
+            return if @bits_in_buffer.zero?
+
+            # Pad with zeros to complete byte
+            padding = 8 - @bits_in_buffer
+            @buffer <<= padding
+            @io.write([@buffer].pack("C"))
+            @buffer = 0
+            @bits_in_buffer = 0
+          end
+
+          # Check if at end of stream
+          #
+          # @return [Boolean] True if no more data available
+          def eof?
+            @mode == :read && @bits_in_buffer.zero? && @io.eof?
+          end
+
+          private
+
+          # Fill buffer with next byte from stream
+          #
+          # @return [void]
+          def fill_buffer
+            byte = @io.read(1)
+            raise EOFError, "Unexpected end of stream" if byte.nil?
+
+            @buffer = byte.unpack1("C")
+            @bits_in_buffer = 8
+          end
+
+          # Flush full buffer byte to stream
+          #
+          # @return [void]
+          def flush_buffer
+            @io.write([@buffer].pack("C"))
+            @buffer = 0
+            @bits_in_buffer = 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Rar
+      module Compression
+        # Algorithm dispatcher for RAR compression
+        #
+        # Selects appropriate compression algorithm based on RAR method
+        # and dispatches to correct encoder/decoder.
+        #
+        # Responsibilities:
+        # - Algorithm selection based on compression method
+        # - Dispatch to appropriate decoder/encoder
+        # - Error handling for unsupported/unknown methods
+        #
+        # Note: Does NOT perform actual compression/decompression
+        # (delegated to decoder/encoder classes)
+        class Dispatcher
+          # RAR compression methods
+          METHOD_STORE = 0x30      # No compression
+          METHOD_FASTEST = 0x31    # LZ77+Huffman (fast)
+          METHOD_FAST = 0x32       # LZ77+Huffman
+          METHOD_NORMAL = 0x33     # LZ77+Huffman (default)
+          METHOD_GOOD = 0x34       # LZ77+Huffman or PPMd
+          METHOD_BEST = 0x35       # PPMd
+
+          # Custom errors
+          class UnsupportedMethodError < StandardError; end
+          class DecompressionError < StandardError; end
+          class CompressionError < StandardError; end
+
+          class << self
+            # Decompress data using appropriate algorithm
+            #
+            # @param method [Integer] RAR compression method (0x30-0x35)
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            # @raise [UnsupportedMethodError] if method unknown
+            # @raise [DecompressionError] if decompression fails
+            def decompress(method, input, output, options = {})
+              case method
+              when METHOD_STORE
+                decompress_store(input, output)
+              when METHOD_FASTEST, METHOD_FAST, METHOD_NORMAL
+                decompress_lz77_huffman(input, output, options)
+              when METHOD_GOOD
+                decompress_good(input, output, options)
+              when METHOD_BEST
+                decompress_ppmd(input, output, options)
+              else
+                raise UnsupportedMethodError,
+                      "Unknown compression method: 0x#{method.to_s(16).upcase}"
+              end
+            rescue StandardError => e
+              unless e.is_a?(UnsupportedMethodError)
+                raise DecompressionError,
+                      "Decompression failed: #{e.message}"
+              end
+
+              raise
+            end
+
+            # Compress data using appropriate algorithm
+            #
+            # @param method [Integer] RAR compression method
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            # @raise [UnsupportedMethodError] if method unknown
+            # @raise [CompressionError] if compression fails
+            # @raise [NotImplementedError] for methods not yet implemented
+            def compress(method, input, output, options = {})
+              case method
+              when METHOD_STORE
+                compress_store(input, output)
+              when METHOD_FASTEST, METHOD_FAST, METHOD_NORMAL
+                compress_lz77_huffman(input, output, options)
+              when METHOD_GOOD
+                compress_good(input, output, options)
+              when METHOD_BEST
+                compress_ppmd(input, output, options)
+              else
+                raise UnsupportedMethodError,
+                      "Unknown compression method: 0x#{method.to_s(16).upcase}"
+              end
+            rescue StandardError => e
+              raise CompressionError, "Compression failed: #{e.message}" unless
+                e.is_a?(UnsupportedMethodError) || e.is_a?(NotImplementedError)
+
+              raise
+            end
+
+            private
+
+            # Decompress METHOD_STORE (no compression)
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            def decompress_store(input, output)
+              # Direct copy, no decompression needed
+              ::IO.copy_stream(input, output)
+            end
+
+            # Decompress using LZ77+Huffman decoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            def decompress_lz77_huffman(input, output, options)
+              decoder = LZ77Huffman::Decoder.new(input, options)
+              decoded_data = decoder.decode
+              output.write(decoded_data)
+            end
+
+            # Decompress METHOD_GOOD (adaptive)
+            #
+            # For now, default to LZ77+Huffman
+            # In future, could analyze content to choose algorithm
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            def decompress_good(input, output, options)
+              # METHOD_GOOD maps to the same LZ77+Huffman pipeline as
+              # METHOD_NORMAL; the RAR method byte distinguishes
+              # effort levels, not algorithms, and the omnizip-rs
+              # reference decodes both identically.
+              decompress_lz77_huffman(input, output, options)
+            end
+
+            # Decompress using PPMd decoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Decoder options
+            def decompress_ppmd(input, output, options)
+              decoder = PPMd::Decoder.new(input, options)
+              decoded_data = decoder.decode_stream
+              output.write(decoded_data)
+            end
+
+            # Compress METHOD_STORE (no compression)
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            def compress_store(input, output)
+              # Direct copy, no compression
+              ::IO.copy_stream(input, output)
+            end
+
+            # Compress using LZ77+Huffman encoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            def compress_lz77_huffman(input, output, options)
+              encoder = LZ77Huffman::Encoder.new(output, options)
+              encoder.encode(input)
+            end
+
+            # Compress METHOD_GOOD (adaptive)
+            #
+            # For now, default to LZ77+Huffman
+            # In future, could analyze content to choose algorithm
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            def compress_good(input, output, options)
+              # METHOD_GOOD compresses with the same LZ77+Huffman
+              # pipeline as METHOD_NORMAL (see decompress_good); the
+              # method byte records the writer's effort level only.
+              compress_lz77_huffman(input, output, options)
+            end
+
+            # Compress using PPMd encoder
+            #
+            # @param input [IO] Input stream
+            # @param output [IO] Output stream
+            # @param options [Hash] Encoder options
+            def compress_ppmd(input, output, options)
+              encoder = PPMd::Encoder.new(output, options)
+              encoder.encode_stream(input)
+            end
+
+            # Select decoder class for method (for testing)
+            #
+            # @param method [Integer] Compression method
+            # @return [Class, nil] Decoder class or nil for METHOD_STORE
+            def select_decoder(method)
+              case method
+              when METHOD_STORE
+                nil
+              when METHOD_FASTEST, METHOD_FAST, METHOD_NORMAL, METHOD_GOOD
+                LZ77Huffman::Decoder
+              when METHOD_BEST
+                PPMd::Decoder
+              else
+                raise UnsupportedMethodError,
+                      "Unknown compression method: 0x#{method.to_s(16).upcase}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+# 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
+          # RAR LZ77+Huffman decoder
+          #
+          # Orchestrates the decoding of RAR METHOD_NORMAL compressed data.
+          # Combines Huffman coding with LZ77 sliding window compression.
+          #
+          # Responsibilities:
+          # - ONE responsibility: Orchestrate LZ77+Huffman decoding
+          # - Parse Huffman trees from bit stream
+          # - Decode symbols using Huffman coder
+          # - Process LZ77 matches via sliding window
+          # - Manage decoder state and output
+          #
+          # RAR LZ77+Huffman Format:
+          # 1. Block header with Huffman tree definitions
+          # 2. Compressed data stream
+          # 3. Symbols: literals (0-255), matches (length+distance), end marker
+          class Decoder
+            # Symbol ranges
+            LITERAL_SYMBOLS = (0..255)
+            END_OF_BLOCK = 256
+            MATCH_SYMBOLS = (257..511)
+
+            # Match parameters
+            MIN_MATCH_LENGTH = 3
+            MAX_MATCH_LENGTH = 257
+
+            # Window size for RAR4
+            DEFAULT_WINDOW_SIZE = 64 * 1024
+
+            # Initialize LZ77+Huffman decoder
+            #
+            # @param input [IO] Compressed input stream
+            # @param options [Hash] Decoding options
+            # @option options [Integer] :window_size Window size in bytes
+            def initialize(input, options = {})
+              @bit_stream = BitStream.new(input, :read)
+              @window = SlidingWindow.new(options[:window_size] || DEFAULT_WINDOW_SIZE)
+              @huffman = HuffmanCoder.new
+              @output = String.new(encoding: Encoding::BINARY)
+            end
+
+            # Decode compressed data
+            #
+            # Main decoding loop:
+            # 1. Parse Huffman tree (simplified for MVP)
+            # 2. Decode symbols until end-of-block
+            # 3. Process literals and matches
+            #
+            # @param max_output [Integer, nil] Maximum output bytes
+            # @return [String] Decoded data
+            def decode(max_output = nil)
+              @output.clear
+
+              # Parse Huffman tree (simplified - real RAR has complex structure)
+              parse_huffman_trees
+
+              # Decode symbols until end-of-block or max output
+              loop do
+                break if max_output && @output.bytesize >= max_output
+
+                symbol = @huffman.decode_symbol(@bit_stream)
+                break if symbol.nil? || symbol == END_OF_BLOCK
+
+                process_symbol(symbol)
+              end
+
+              @output
+            rescue EOFError
+              @output
+            end
+
+            # Get window size
+            #
+            # @return [Integer] Window size in bytes
+            def window_size
+              @window.size
+            end
+
+            private
+
+            # Parse Huffman trees from bit stream
+            #
+            # RAR uses multiple Huffman tables for different symbol types.
+            # This is a simplified implementation for MVP.
+            #
+            # Simplified format (written by Encoder):
+            # 1. 16-bit number of symbols (always 512 for MVP)
+            # 2. Code lengths (4 bits each, 512 × 4 bits = 2048 bits = 256 bytes)
+            #
+            # Real RAR format:
+            # - MC table: Main code (literals + length codes)
+            # - LD table: Low distance bits
+            # - RC table: Repeat codes
+            # - LDD table: Low distance for distance codes
+            #
+            # @return [void]
+            def parse_huffman_trees
+              # Read number of symbols from encoder (16-bit header)
+              num_symbols = @bit_stream.read_bits(16)
+
+              # Parse tree structure
+              @huffman.parse_tree(@bit_stream, num_symbols)
+            end
+
+            # Process a decoded symbol
+            #
+            # Symbol types:
+            # - 0-255: Literal byte
+            # - 256: End of block
+            # - 257-511: Match (length+distance)
+            #
+            # @param symbol [Integer] Decoded symbol
+            # @return [void]
+            def process_symbol(symbol)
+              if LITERAL_SYMBOLS.cover?(symbol)
+                process_literal(symbol)
+              elsif MATCH_SYMBOLS.cover?(symbol)
+                process_match(symbol)
+              end
+            end
+
+            # Process literal byte
+            #
+            # @param byte [Integer] Literal byte value (0-255)
+            # @return [void]
+            def process_literal(byte)
+              @output << byte.chr
+              @window.add_byte(byte)
+            end
+
+            # Process LZ77 match
+            #
+            # Match symbol encodes both length and distance information.
+            # Additional bits may be read for exact values.
+            #
+            # @param symbol [Integer] Match symbol (257-511)
+            # @return [void]
+            def process_match(symbol)
+              length = decode_match_length(symbol)
+              distance = decode_match_distance
+
+              # Copy match from window
+              match_bytes = @window.copy_match(distance, length)
+              match_bytes.each { |byte| @output << byte.chr }
+            end
+
+            # Decode match length from symbol
+            #
+            # RAR encodes length in the symbol itself plus extra bits.
+            # This is simplified for MVP.
+            #
+            # @param symbol [Integer] Match symbol
+            # @return [Integer] Match length
+            def decode_match_length(symbol)
+              # Simplified length decoding
+              # Real RAR uses complex length encoding with extra bits
+
+              base_length = symbol - 257 + MIN_MATCH_LENGTH
+
+              # Could read extra bits here for longer lengths
+              # For now, use base length
+              [base_length, MAX_MATCH_LENGTH].min
+            end
+
+            # Decode match distance
+            #
+            # Distance is encoded separately, often with additional
+            # Huffman tables and extra bits.
+            #
+            # @return [Integer] Match distance
+            def decode_match_distance
+              # Simplified distance decoding
+              # Real RAR uses separate Huffman table for distance
+
+              # Read distance as direct bits (simplified)
+              # Real implementation would use distance Huffman table
+              distance_bits = 16 # Changed from 8 to 16 bits for 64KB window
+              @bit_stream.read_bits(distance_bits)
+            end
+          end
+        end
+      end
+    end
+  end
+end