omnizip 0.3.1

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

@@ -0,0 +1,193 @@
+# 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 "bwt"
+require_relative "mtf"
+require_relative "rle"
+require_relative "huffman"
+require_relative "../../checksums/crc32"
+
+module Omnizip
+  module Algorithms
+    class BZip2 < Algorithm
+      # BZip2 Decoder
+      #
+      # Reverses the full BZip2 compression pipeline:
+      # 1. Read block headers
+      # 2. Decode Huffman coding
+      # 3. Reverse Run-Length Encoding (RLE)
+      # 4. Reverse Move-to-Front Transform (MTF)
+      # 5. Reverse Burrows-Wheeler Transform (BWT)
+      # 6. Verify CRC32 checksum
+      #
+      # Processes each block independently and concatenates results.
+      class Decoder
+        attr_reader :input
+
+        # Initialize decoder
+        #
+        # @param input [IO] Input stream
+        # @param options [Hash] Decoding options
+        def initialize(input, _options = {})
+          @input = input
+          @bwt = Bwt.new
+          @mtf = Mtf.new
+          @rle = Rle.new
+          @huffman = Huffman.new
+        end
+
+        # Decode stream using BZip2 algorithm
+        #
+        # @return [String] Decoded data
+        def decode_stream
+          result = []
+
+          # Read and decode all blocks
+          loop do
+            block_data = decode_block
+            break unless block_data
+
+            result << block_data
+          end
+
+          result.join.b
+        end
+
+        private
+
+        # Decode single block
+        #
+        # @return [String, nil] Decoded block or nil if no more blocks
+        def decode_block
+          # Read block header
+          crc_bytes = @input.read(4)
+          return nil unless crc_bytes && crc_bytes.length == 4
+
+          expected_crc = crc_bytes.unpack1("N")
+          primary_index = @input.read(4).unpack1("N")
+          @input.read(4).unpack1("N")
+          rle_length = @input.read(4).unpack1("N")
+
+          # Read Huffman code table
+          codes = read_huffman_codes
+
+          # Read encoded data
+          encoded_length = @input.read(4).unpack1("N")
+          encoded_data = @input.read(encoded_length)
+
+          # Rebuild Huffman tree from codes
+          tree = rebuild_huffman_tree(codes)
+
+          # Decode Huffman
+          rle_data = @huffman.decode(encoded_data, tree, rle_length)
+
+          # Reverse RLE
+          mtf_data = @rle.decode(rle_data)
+
+          # Reverse MTF
+          bwt_data = @mtf.decode(mtf_data)
+
+          # Reverse BWT
+          original_data = @bwt.decode(bwt_data, primary_index)
+
+          # Verify CRC
+          actual_crc = Checksums::Crc32.calculate(original_data)
+          if actual_crc != expected_crc
+            raise "CRC mismatch: expected #{expected_crc}, " \
+                  "got #{actual_crc}"
+          end
+
+          original_data
+        end
+
+        # Read Huffman code table from stream
+        #
+        # @return [Hash<Integer, String>] Symbol => binary code
+        def read_huffman_codes
+          codes = {}
+          code_count = @input.read(2).unpack1("n")
+
+          code_count.times do
+            symbol = @input.read(1).unpack1("C")
+            code_length = @input.read(1).unpack1("C")
+            codes[symbol] = code_length
+          end
+
+          codes
+        end
+
+        # Rebuild Huffman tree from code lengths
+        #
+        # Creates canonical Huffman codes and builds tree
+        #
+        # @param code_lengths [Hash<Integer, Integer>] Symbol => length
+        # @return [Huffman::Node] Root of Huffman tree
+        def rebuild_huffman_tree(code_lengths)
+          # Sort symbols by code length, then by symbol value
+          sorted_symbols = code_lengths.sort_by { |sym, len| [len, sym] }
+
+          # Generate canonical codes
+          codes = {}
+          code_value = 0
+          prev_length = 0
+
+          sorted_symbols.each do |symbol, length|
+            # Shift code value for new length
+            code_value <<= (length - prev_length)
+            codes[symbol] = format("%0#{length}b", code_value)
+            code_value += 1
+            prev_length = length
+          end
+
+          # Build tree from codes
+          build_tree_from_codes(codes)
+        end
+
+        # Build Huffman tree from code strings
+        #
+        # @param codes [Hash<Integer, String>] Symbol => binary code
+        # @return [Huffman::Node] Root node
+        def build_tree_from_codes(codes)
+          root = Huffman::Node.new(nil, 0)
+
+          codes.each do |symbol, code|
+            current = root
+
+            code.each_char do |bit|
+              if bit == "0"
+                current.left ||= Huffman::Node.new(nil, 0)
+                current = current.left
+              else
+                current.right ||= Huffman::Node.new(nil, 0)
+                current = current.right
+              end
+            end
+
+            current.symbol = symbol
+          end
+
+          root
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+# 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 "bwt"
+require_relative "mtf"
+require_relative "rle"
+require_relative "huffman"
+require_relative "../../checksums/crc32"
+
+module Omnizip
+  module Algorithms
+    class BZip2 < Algorithm
+      # BZip2 Encoder
+      #
+      # Orchestrates the full BZip2 compression pipeline:
+      # 1. Block splitting (configurable block size)
+      # 2. Burrows-Wheeler Transform (BWT)
+      # 3. Move-to-Front Transform (MTF)
+      # 4. Run-Length Encoding (RLE)
+      # 5. Huffman Coding
+      # 6. CRC32 checksum calculation
+      #
+      # Each block is compressed independently for better parallelization
+      # potential and error recovery.
+      class Encoder
+        attr_reader :output, :block_size
+
+        # Block size constants (in bytes)
+        MIN_BLOCK_SIZE = 100_000  # 100KB
+        MAX_BLOCK_SIZE = 900_000  # 900KB
+        DEFAULT_BLOCK_SIZE = 900_000 # 900KB (level 9)
+
+        # Initialize encoder
+        #
+        # @param output [IO] Output stream
+        # @param options [Hash] Encoding options
+        # @option options [Integer] :block_size Block size in bytes
+        def initialize(output, options = {})
+          @output = output
+          @block_size = validate_block_size(
+            options[:block_size] || DEFAULT_BLOCK_SIZE,
+          )
+          @bwt = Bwt.new
+          @mtf = Mtf.new
+          @rle = Rle.new
+          @huffman = Huffman.new
+        end
+
+        # Encode stream using BZip2 algorithm
+        #
+        # @param input [String] Input data to encode
+        # @return [void]
+        def encode_stream(input)
+          return if input.empty?
+
+          # Split into blocks and encode each
+          blocks = split_into_blocks(input)
+          blocks.each { |block| encode_block(block) }
+        end
+
+        private
+
+        # Validate and clamp block size to valid range
+        #
+        # @param size [Integer] Requested block size
+        # @return [Integer] Validated block size
+        def validate_block_size(size)
+          size.clamp(MIN_BLOCK_SIZE, MAX_BLOCK_SIZE)
+        end
+
+        # Split input into blocks
+        #
+        # @param input [String] Input data
+        # @return [Array<String>] Array of blocks
+        def split_into_blocks(input)
+          blocks = []
+          offset = 0
+
+          while offset < input.length
+            block = input[offset, @block_size]
+            blocks << block if block && !block.empty?
+            offset += @block_size
+          end
+
+          blocks
+        end
+
+        # Encode single block through full pipeline
+        #
+        # @param block [String] Block data
+        # @return [void]
+        def encode_block(block)
+          # Calculate CRC of original data
+          crc = Checksums::Crc32.calculate(block)
+
+          # Apply BWT
+          bwt_data, primary_index = @bwt.encode(block)
+
+          # Apply MTF
+          mtf_data = @mtf.encode(bwt_data)
+
+          # Apply RLE
+          rle_data = @rle.encode(mtf_data)
+
+          # Build frequency table for Huffman
+          frequencies = build_frequency_table(rle_data)
+
+          # Build Huffman tree and generate codes
+          tree = @huffman.build_tree(frequencies)
+          codes = generate_canonical_codes(tree)
+
+          # Encode data with Huffman
+          encoded_data = @huffman.encode(rle_data, codes)
+
+          # Write block to output
+          write_block(crc, primary_index, block.length, codes,
+                      encoded_data, rle_data.length)
+        end
+
+        # Build frequency table from data
+        #
+        # @param data [String] Input data
+        # @return [Hash<Integer, Integer>] Byte => frequency
+        def build_frequency_table(data)
+          freq = Hash.new(0)
+          data.each_byte { |byte| freq[byte] += 1 }
+          freq
+        end
+
+        # Generate canonical Huffman codes from tree
+        #
+        # @param tree [Huffman::Node] Huffman tree root
+        # @return [Hash<Integer, String>] Symbol => canonical code
+        def generate_canonical_codes(tree)
+          # Get standard codes first
+          standard_codes = @huffman.generate_codes(tree)
+
+          # Convert to code lengths
+          code_lengths = {}
+          standard_codes.each do |symbol, code|
+            code_lengths[symbol] = code.length
+          end
+
+          # Generate canonical codes from lengths
+          # Sort by (length, symbol) to ensure deterministic ordering
+          sorted_symbols = code_lengths.sort_by { |sym, len| [len, sym] }
+
+          canonical_codes = {}
+          code_value = 0
+          prev_length = 0
+
+          sorted_symbols.each do |symbol, length|
+            # Shift code value for new length
+            code_value <<= (length - prev_length)
+            canonical_codes[symbol] = format("%0#{length}b", code_value)
+            code_value += 1
+            prev_length = length
+          end
+
+          canonical_codes
+        end
+
+        # Write encoded block to output
+        #
+        # @param crc [Integer] CRC32 of original block
+        # @param primary_index [Integer] BWT primary index
+        # @param original_length [Integer] Original block length
+        # @param codes [Hash] Huffman codes
+        # @param encoded_data [String] Huffman-encoded data
+        # @param rle_length [Integer] Length after RLE
+        # @return [void]
+        def write_block(crc, primary_index, original_length, codes,
+                        encoded_data, rle_length)
+          write_block_header(crc, primary_index, original_length, rle_length)
+          write_huffman_codes(codes)
+          write_encoded_data(encoded_data)
+        end
+
+        # Write block header
+        #
+        # @param crc [Integer] CRC32 checksum
+        # @param primary_index [Integer] BWT primary index
+        # @param original_length [Integer] Original block length
+        # @param rle_length [Integer] RLE length
+        # @return [void]
+        def write_block_header(crc, primary_index, original_length,
+                               rle_length)
+          @output.write([crc].pack("N"))
+          @output.write([primary_index].pack("N"))
+          @output.write([original_length].pack("N"))
+          @output.write([rle_length].pack("N"))
+        end
+
+        # Write Huffman codes to output
+        #
+        # @param codes [Hash] Huffman codes
+        # @return [void]
+        def write_huffman_codes(codes)
+          @output.write([codes.size].pack("n"))
+
+          codes.each do |symbol, code|
+            @output.write([symbol].pack("C"))
+            @output.write([code.length].pack("C"))
+          end
+        end
+
+        # Write encoded data to output
+        #
+        # @param encoded_data [String] Huffman-encoded data
+        # @return [void]
+        def write_encoded_data(encoded_data)
+          @output.write([encoded_data.length].pack("N"))
+          @output.write(encoded_data)
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/bzip2/huffman.rb

@@ -0,0 +1,206 @@
+# 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 BZip2 < Algorithm
+      # Huffman Coding for BZip2
+      #
+      # Implements canonical Huffman coding for the final compression
+      # stage of BZip2. Huffman coding assigns variable-length codes
+      # to symbols based on their frequencies, with more frequent
+      # symbols getting shorter codes.
+      #
+      # This implementation:
+      # 1. Builds a Huffman tree from symbol frequencies
+      # 2. Generates canonical codes for efficient decoding
+      # 3. Encodes data as a bit stream
+      # 4. Decodes bit streams back to symbols
+      class Huffman
+        # Huffman tree node
+        class Node
+          attr_accessor :symbol, :frequency, :left, :right
+
+          # Initialize node
+          #
+          # @param symbol [Integer, nil] Symbol (nil for internal nodes)
+          # @param frequency [Integer] Frequency/weight
+          def initialize(symbol, frequency)
+            @symbol = symbol
+            @frequency = frequency
+            @left = nil
+            @right = nil
+          end
+
+          # Check if node is a leaf
+          #
+          # @return [Boolean] True if leaf node
+          def leaf?
+            @left.nil? && @right.nil?
+          end
+        end
+
+        # Build Huffman tree from frequency table
+        #
+        # @param frequencies [Hash<Integer, Integer>] Symbol => frequency
+        # @return [Node, nil] Root node of Huffman tree
+        def build_tree(frequencies)
+          return nil if frequencies.empty?
+
+          # Create leaf nodes
+          nodes = frequencies.map do |symbol, freq|
+            Node.new(symbol, freq)
+          end
+
+          # Build tree bottom-up
+          while nodes.length > 1
+            # Sort by frequency
+            nodes.sort_by!(&:frequency)
+
+            # Take two lowest frequency nodes
+            left = nodes.shift
+            right = nodes.shift
+
+            # Create parent node
+            parent = Node.new(nil, left.frequency + right.frequency)
+            parent.left = left
+            parent.right = right
+
+            # Add back to nodes
+            nodes << parent
+          end
+
+          nodes.first
+        end
+
+        # Generate code table from Huffman tree
+        #
+        # @param root [Node] Root of Huffman tree
+        # @return [Hash<Integer, String>] Symbol => binary code
+        def generate_codes(root)
+          return {} if root.nil?
+
+          codes = {}
+          generate_codes_recursive(root, "", codes)
+          codes
+        end
+
+        # Encode data using Huffman codes
+        #
+        # @param data [String] Input data to encode
+        # @param codes [Hash<Integer, String>] Symbol => binary code
+        # @return [String] Encoded bit stream (as binary string)
+        def encode(data, codes)
+          return "".b if data.empty?
+
+          bits = []
+
+          data.each_byte do |byte|
+            code = codes[byte]
+            raise "No code for byte #{byte}" unless code
+
+            bits << code
+          end
+
+          bits_to_bytes(bits.join)
+        end
+
+        # Decode bit stream using Huffman tree
+        #
+        # @param bits [String] Encoded bit stream
+        # @param root [Node] Root of Huffman tree
+        # @param length [Integer] Expected output length
+        # @return [String] Decoded data
+        def decode(bits, root, length)
+          return "".b if bits.empty? || root.nil?
+
+          result = []
+          current = root
+          bit_string = bytes_to_bits(bits)
+          bit_index = 0
+
+          while result.length < length && bit_index < bit_string.length
+            bit = bit_string[bit_index]
+            bit_index += 1
+
+            # Navigate tree
+            current = (bit == "0" ? current.left : current.right)
+
+            # Check if we reached a leaf
+            if current.leaf?
+              result << current.symbol
+              current = root
+            end
+          end
+
+          result.pack("C*")
+        end
+
+        private
+
+        # Recursively generate codes for all symbols
+        #
+        # @param node [Node] Current node
+        # @param code [String] Current code path
+        # @param codes [Hash] Code table being built
+        # @return [void]
+        def generate_codes_recursive(node, code, codes)
+          return if node.nil?
+
+          if node.leaf?
+            codes[node.symbol] = code.empty? ? "0" : code
+          else
+            generate_codes_recursive(node.left, "#{code}0", codes)
+            generate_codes_recursive(node.right, "#{code}1", codes)
+          end
+        end
+
+        # Convert bit string to bytes
+        #
+        # @param bits [String] Bit string (e.g., "10110101")
+        # @return [String] Byte string
+        def bits_to_bytes(bits)
+          # Pad to multiple of 8
+          padding = (8 - (bits.length % 8)) % 8
+          bits += ("0" * padding)
+
+          # Convert to bytes
+          bytes = []
+          (0...bits.length).step(8) do |i|
+            byte_bits = bits[i, 8]
+            bytes << byte_bits.to_i(2)
+          end
+
+          bytes.pack("C*")
+        end
+
+        # Convert bytes to bit string
+        #
+        # @param bytes [String] Byte string
+        # @return [String] Bit string
+        def bytes_to_bits(bytes)
+          bytes.bytes.map { |b| format("%08b", b) }.join
+        end
+      end
+    end
+  end
+end