omnizip 0.4.7-x86_64-linux

data/lib/omnizip/filters/xz_delta.rb

@@ -0,0 +1,258 @@
+# 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.
+#
+# XZ Utils Delta filter implementation.
+#
+# This is the XZ Utils Delta filter (filter ID 0x03), which is DIFFERENT
+# from the 7-Zip Delta filter. Both compute byte-wise differences but use
+# different algorithms:
+#
+# - 7-Zip Delta: Simple forward difference (new[i] = old[i] - old[i-distance])
+# - XZ Utils Delta: Uses a 256-byte circular history buffer
+#
+# Reference: /Users/mulgogi/src/external/xz/src/liblzma/delta/
+#
+# Algorithm summary:
+# - Maintains a 256-byte circular history buffer
+# - Encoder: out[i] = in[i] - history[(distance + pos) & 0xFF]
+# - Decoder: out[i] = in[i] + history[(distance + pos) & 0xFF]
+# - history[pos & 0xFF] = processed_byte (updated in both encode/decode)
+# - pos decrements each byte, wrapping via & 0xFF
+#
+# The distance parameter (1-256) determines how far back in the history
+# to look for the delta reference value.
+
+module Omnizip
+  module Filters
+    # XZ Utils Delta filter.
+    #
+    # This filter computes byte-wise differences using a 256-byte circular
+    # history buffer. It is particularly effective for:
+    # - Stereo audio (distance=4 for 16-bit samples)
+    # - RGB images (distance=3)
+    # - RGBA images (distance=4)
+    # - Multi-channel data with regular patterns
+    #
+    # This is DIFFERENT from the 7-Zip Delta filter which uses simple
+    # forward differences without a history buffer.
+    #
+    # Reference: XZ Utils delta_encoder.c, delta_decoder.c
+    class XzDeltaFilter
+      # Filter ID for XZ format
+      FILTER_ID = 0x03
+
+      # Minimum distance value (XZ Utils LZMA_DELTA_DIST_MIN)
+      DELTA_DIST_MIN = 1
+
+      # Maximum distance value (XZ Utils LZMA_DELTA_DIST_MAX)
+      DELTA_DIST_MAX = 256
+
+      # History buffer size (always 256 bytes in XZ Utils)
+      HISTORY_SIZE = 256
+
+      # Delta type (only BYTE is supported in XZ Utils)
+      DELTA_TYPE_BYTE = 0
+
+      attr_reader :distance
+
+      # Initialize the Delta filter.
+      #
+      # @param distance [Integer] Byte distance for delta calculation (1-256)
+      # @raise [ArgumentError] If distance is invalid
+      def initialize(distance = DELTA_DIST_MIN)
+        validate_distance(distance)
+        @distance = distance
+        # Initialize state (matches XZ Utils lzma_delta_coder_init)
+        @pos = 0
+        @history = ("\x00" * HISTORY_SIZE).b
+      end
+
+      # Encode (preprocess) data by computing forward differences.
+      #
+      # For each byte:
+      #   tmp = history[(distance + pos) & 0xFF]
+      #   history[pos & 0xFF] = in[i]
+      #   out[i] = in[i] - tmp (mod 256)
+      #   pos--
+      #
+      # Reference: XZ Utils delta_encoder.c:copy_and_encode
+      #
+      # @param data [String] Binary data to encode
+      # @return [String] Encoded binary data
+      def encode(data)
+        return data.dup.b if data.empty?
+
+        result = data.dup.b
+        data.bytes.each_with_index do |byte, i|
+          # Get historical value from distance positions back
+          tmp = @history.getbyte((@distance + @pos) & 0xFF)
+
+          # Store current byte in history
+          @history.setbyte(@pos & 0xFF, byte)
+
+          # Output is the difference
+          result.setbyte(i, (byte - tmp) & 0xFF)
+
+          # Move position backward (wraps via & 0xFF)
+          @pos = (@pos - 1) & 0xFF
+        end
+
+        result
+      end
+
+      # Decode (postprocess) data by restoring from differences.
+      #
+      # For each byte:
+      #   buffer[i] += history[(distance + pos) & 0xFF] (mod 256)
+      #   history[pos & 0xFF] = buffer[i]
+      #   pos--
+      #
+      # Reference: XZ Utils delta_decoder.c:decode_buffer
+      #
+      # @param data [String] Binary data to decode
+      # @return [String] Decoded binary data
+      def decode(data)
+        return data.dup.b if data.empty?
+
+        result = data.dup.b
+        data.bytes.each_with_index do |byte, i|
+          # Get historical value from distance positions back
+          tmp = @history.getbyte((@distance + @pos) & 0xFF)
+
+          # Restore original value by adding the difference
+          result.setbyte(i, (byte + tmp) & 0xFF)
+
+          # Store restored byte in history
+          @history.setbyte(@pos & 0xFF, result.getbyte(i))
+
+          # Move position backward (wraps via & 0xFF)
+          @pos = (@pos - 1) & 0xFF
+        end
+
+        result
+      end
+
+      # Reset the filter state.
+      #
+      # This clears the history buffer and resets position to 0.
+      # Used when initializing a new filter chain.
+      #
+      # @return [void]
+      def reset
+        @pos = 0
+        @history = ("\x00" * HISTORY_SIZE).b
+      end
+
+      class << self
+        # Decode properties byte to get distance.
+        #
+        # XZ Utils encodes distance as: props[0] = dist - 1
+        # So we decode as: dist = props[0] + 1
+        #
+        # Reference: XZ Utils delta_decoder.c:lzma_delta_props_decode
+        #
+        # @param properties [String] Properties byte (1 byte)
+        # @return [Integer] Distance value (1-256)
+        # @raise [ArgumentError] If properties size is invalid
+        def decode_properties(properties)
+          unless properties.is_a?(String) && properties.bytesize == 1
+            raise ArgumentError,
+                  "Delta filter requires exactly 1 property byte, got #{properties&.bytesize}"
+          end
+
+          props_byte = properties.getbyte(0)
+          # XZ Utils: opt->dist = props[0] + LZMA_DELTA_DIST_MIN
+          # where LZMA_DELTA_DIST_MIN = 1
+          distance = props_byte + DELTA_DIST_MIN
+
+          # Validate distance is in valid range (inline for class method)
+          unless distance.between?(DELTA_DIST_MIN, DELTA_DIST_MAX)
+            raise ArgumentError,
+                  "Invalid distance #{distance}, must be between #{DELTA_DIST_MIN} and #{DELTA_DIST_MAX}"
+          end
+
+          distance
+        end
+
+        # Encode distance to properties byte.
+        #
+        # XZ Utils encodes distance as: props[0] = dist - 1
+        #
+        # Reference: XZ Utils delta_encoder.c:lzma_delta_props_encode
+        #
+        # @param distance [Integer] Distance value (1-256)
+        # @return [String] Properties byte (1 byte)
+        # @raise [ArgumentError] If distance is invalid
+        def encode_properties(distance)
+          # Validate distance (inline for class method)
+          unless distance.is_a?(Integer)
+            raise ArgumentError,
+                  "Distance must be an integer, got #{distance.class}"
+          end
+
+          unless distance.between?(DELTA_DIST_MIN, DELTA_DIST_MAX)
+            raise ArgumentError,
+                  "Distance must be between #{DELTA_DIST_MIN} and #{DELTA_DIST_MAX}, got #{distance}"
+          end
+
+          # XZ Utils: out[0] = opt->dist - LZMA_DELTA_DIST_MIN
+          # where LZMA_DELTA_DIST_MIN = 1
+          props_byte = distance - DELTA_DIST_MIN
+
+          [props_byte].pack("C")
+        end
+
+        # Get metadata about this filter.
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "XZ Delta",
+            description: "XZ Utils Delta filter with 256-byte circular history buffer",
+            filter_id: FILTER_ID,
+            typical_usage: "WAV audio (distance=4), BMP images (distance=3), " \
+                           "multi-channel data with regular patterns",
+          }
+        end
+      end
+
+      private
+
+      # Validate distance parameter.
+      #
+      # @param dist [Integer] Distance value to validate
+      # @raise [ArgumentError] If distance is invalid
+      # @return [void]
+      def validate_distance(dist)
+        unless dist.is_a?(Integer)
+          raise ArgumentError, "Distance must be an integer, got #{dist.class}"
+        end
+
+        unless dist.between?(DELTA_DIST_MIN, DELTA_DIST_MAX)
+          raise ArgumentError,
+                "Distance must be between #{DELTA_DIST_MIN} and #{DELTA_DIST_MAX}, got #{dist}"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/filters.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Filter implementations for preprocessing data before compression
+  module Filters
+    autoload :BCJ, "omnizip/filters/bcj"
+    autoload :BcjX86, "omnizip/filters/bcj_x86"
+    autoload :Bcj2, "omnizip/filters/bcj2"
+    autoload :Bcj2Constants, "omnizip/filters/bcj2/constants"
+    autoload :Bcj2StreamData, "omnizip/filters/bcj2/stream_data"
+    autoload :Bcj2Decoder, "omnizip/filters/bcj2/decoder"
+    autoload :Bcj2Encoder, "omnizip/filters/bcj2/encoder"
+    autoload :BcjArm, "omnizip/filters/bcj_arm"
+    autoload :BcjArm64, "omnizip/filters/bcj_arm64"
+    autoload :BcjPpc, "omnizip/filters/bcj_ppc"
+    autoload :BcjSparc, "omnizip/filters/bcj_sparc"
+    autoload :BcjIa64, "omnizip/filters/bcj_ia64"
+    autoload :Delta, "omnizip/filters/delta"
+  end
+end

data/lib/omnizip/format_detector.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Detects archive format from file signature/magic bytes
+  #
+  # This class identifies archive formats based on their file signatures.
+  # It distinguishes between XZ Utils format (.xz) and 7-Zip format (.7z)
+  # which are DIFFERENT implementations of LZMA/LZMA2 compression.
+  #
+  # @example Basic usage
+  #   format = Omnizip::FormatDetector.detect("archive.xz")
+  #   case format
+  #   when :xz
+  #     # Use XZ Utils implementation
+  #   when :seven_zip
+  #     # Use 7-Zip implementation
+  #   end
+  #
+  class FormatDetector
+    # XZ Utils format signature: "\xFD7zXZ\x00"
+    XZ_SIGNATURE = [0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00].freeze
+
+    # 7-Zip format signature: "7z\xBC\xAF\x27\x1C"
+    SEVEN_ZIP_SIGNATURE = [0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C].freeze
+
+    # RAR5 format signature: "Rar!\x1A\x07\x01\x00"
+    RAR5_SIGNATURE = [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x01, 0x00].freeze
+
+    # RAR4 format signature: "Rar!\x1A\x07\x00"
+    RAR4_SIGNATURE = [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00].freeze
+
+    # ZIP format signature: "PK\x03\x04"
+    ZIP_SIGNATURE = [0x50, 0x4B, 0x03, 0x04].freeze
+
+    # GZIP format signature: "\x1F\x8B"
+    GZIP_SIGNATURE = [0x1F, 0x8B].freeze
+
+    # BZIP2 format signature: "BZ"
+    BZIP2_SIGNATURE = [0x42, 0x5A].freeze
+
+    # Detect archive format from file path
+    #
+    # @param file_path [String] Path to the archive file
+    # @return [Symbol, nil] Format identifier (:xz, :seven_zip, :rar5, :rar4,
+    #   :zip, :gzip, :bzip2, :lzma_alone) or nil if unknown
+    def self.detect(file_path)
+      return nil unless File.exist?(file_path)
+
+      header = File.binread(file_path, 16)
+      return nil if header.nil? || header.empty?
+
+      bytes = header.bytes
+
+      case bytes
+      in [0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00, *]
+        :xz
+      in [0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C, *]
+        :seven_zip
+      in [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x01, 0x00, *]
+        :rar5
+      in [0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00, *]
+        :rar4
+      in [0x50, 0x4B, 0x03, 0x04, *]
+        :zip
+      in [0x1F, 0x8B, *]
+        :gzip
+      in [0x42, 0x5A, *]
+        :bzip2
+      else
+        # Check for LZMA_Alone format (13-byte header with properties)
+        detect_lzma_alone(bytes)
+      end
+    end
+
+    # Check if file is XZ Utils format
+    #
+    # @param file_path [String] Path to the file
+    # @return [Boolean] true if XZ format
+    def self.xz?(file_path)
+      detect(file_path) == :xz
+    end
+
+    # Check if file is 7-Zip format
+    #
+    # @param file_path [String] Path to the file
+    # @return [Boolean] true if 7-Zip format
+    def self.seven_zip?(file_path)
+      detect(file_path) == :seven_zip
+    end
+
+    # Check if file is RAR5 format
+    #
+    # @param file_path [String] Path to the file
+    # @return [Boolean] true if RAR5 format
+    def self.rar5?(file_path)
+      detect(file_path) == :rar5
+    end
+
+    # Check if file is RAR4 format
+    #
+    # @param file_path [String] Path to the file
+    # @return [Boolean] true if RAR4 format
+    def self.rar4?(file_path)
+      detect(file_path) == :rar4
+    end
+
+    # Mapping of detected format symbols to (extension, constant-path)
+    # tuples. The constant path is resolved lazily so autoload fires
+    # only when a format is actually requested.
+    READER_FOR_FORMAT = {
+      xz: ["omnizip/formats/xz", "Omnizip::Formats::Xz"],
+      seven_zip: ["omnizip/formats/seven_zip", "Omnizip::Formats::SevenZip::Reader"],
+      rar5: ["omnizip/formats/rar5", "Omnizip::Formats::Rar5::Reader"],
+      rar4: ["omnizip/formats/rar3", "Omnizip::Formats::Rar3::Reader"],
+      zip: ["omnizip/formats/zip", "Omnizip::Formats::Zip::Reader"],
+      gzip: ["omnizip/formats/gzip", "Omnizip::Formats::Gzip"],
+      bzip2: ["omnizip/formats/bzip2_file", "Omnizip::Formats::Bzip2File"],
+    }.freeze
+
+    # Get the appropriate reader class for the format
+    #
+    # @param file_path [String] Path to the archive file
+    # @return [Class, nil] Reader class or nil if unknown format
+    def self.reader_for(file_path)
+      format = detect(file_path)
+      return nil unless format
+
+      mapping = READER_FOR_FORMAT[format]
+      return nil unless mapping
+
+      _path, const_path = mapping
+      Object.const_get(const_path)
+    end
+
+    # Detect LZMA_Alone format
+    #
+    # LZMA_Alone format has a 13-byte header:
+    # - 1 byte: properties (lc, lp, pb encoded)
+    # - 4 bytes: dictionary size (little-endian)
+    # - 8 bytes: uncompressed size (little-endian, -1 for unknown)
+    #
+    # @param bytes [Array<Integer>] First bytes of file
+    # @return [Symbol, nil] :lzma_alone or nil
+    def self.detect_lzma_alone(bytes)
+      return nil if bytes.size < 13
+
+      # Check properties byte (must be valid lc/lp/pb encoding)
+      props = bytes[0]
+      return nil if props > 225 # Max valid value is (9 * 5 * 5) - 1 = 224
+
+      lc = props % 9
+      lp = (props / 9) % 5
+      pb = props / 45
+
+      # Validate ranges
+      return nil if lc > 8 || lp > 4 || pb > 4
+
+      # Dictionary size should be power of 2 or close to it
+      dict_size = bytes[1, 4].pack("C*").unpack1("V")
+      return nil if dict_size.zero? || dict_size > (1 << 30) # Max ~1GB
+
+      :lzma_alone
+    end
+    private_class_method :detect_lzma_alone
+  end
+end

data/lib/omnizip/formats/bzip2_file.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Omnizip
+  module Formats
+    # BZIP2 file format
+    #
+    # BZIP2 is a file compression format that uses the BZip2 algorithm
+    # with block-sorting compression (Burrows-Wheeler Transform).
+    #
+    # Format structure:
+    # - Magic bytes: "BZh" (0x42 0x5A 0x68)
+    # - Block size indicator: '1'-'9' (100KB - 900KB)
+    # - Compressed blocks
+    # - End-of-stream marker
+    #
+    # The format supports multiple compressed blocks, each with its own
+    # CRC32 checksum for data integrity verification.
+    module Bzip2File
+      # BZIP2 magic bytes
+      BZIP2_MAGIC = "BZh"
+
+      # Block size markers ('1' to '9')
+      BLOCK_SIZE_MIN = 1
+      BLOCK_SIZE_MAX = 9
+
+      # Stream markers
+      STREAM_MAGIC = 0x314159265359 # π in hex
+      BLOCK_MAGIC = 0x177245385090  # Block start marker
+      STREAM_END_MAGIC = 0x177245385090 # Stream end marker
+
+      class << self
+        # Compress a file with BZIP2
+        #
+        # @param input_path [String] Input file path
+        # @param output_path [String] Output BZIP2 file path
+        # @param options [Hash] Compression options
+        # @option options [Integer] :level Compression level (1-9)
+        def compress(input_path, output_path, options = {})
+          input_data = File.binread(input_path)
+
+          File.open(output_path, "wb") do |output|
+            compress_stream(StringIO.new(input_data), output, options)
+          end
+        end
+
+        # Decompress a BZIP2 file
+        #
+        # @param input_path [String] Input BZIP2 file path
+        # @param output_path [String] Output file path
+        def decompress(input_path, output_path)
+          File.open(input_path, "rb") do |input|
+            File.open(output_path, "wb") do |output|
+              decompress_stream(input, output)
+            end
+          end
+        end
+
+        # Compress data stream with BZIP2
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        # @param options [Hash] Compression options
+        def compress_stream(input_io, output_io, options = {})
+          level = options[:level] || 9
+          level = level.clamp(BLOCK_SIZE_MIN, BLOCK_SIZE_MAX)
+
+          input_data = input_io.read
+
+          # Write BZIP2 header
+          write_header(output_io, level)
+
+          # Get BZip2 algorithm
+          bzip2 = AlgorithmRegistry.get(:bzip2).new
+
+          # Compress data
+          compressed_io = StringIO.new
+          compressed_io.set_encoding(Encoding::BINARY)
+
+          bzip2.compress(
+            StringIO.new(input_data),
+            compressed_io,
+            build_compression_options(level),
+          )
+
+          # Write compressed data
+          compressed_io.rewind
+          compressed_data = compressed_io.read
+          output_io.write(compressed_data)
+        end
+
+        # Decompress BZIP2 stream
+        #
+        # @param input_io [IO] Input stream
+        # @param output_io [IO] Output stream
+        def decompress_stream(input_io, output_io)
+          # Read and verify header
+          read_header(input_io)
+
+          # Get BZip2 algorithm
+          bzip2 = AlgorithmRegistry.get(:bzip2).new
+
+          # Decompress data
+          decompressed_io = StringIO.new
+          decompressed_io.set_encoding(Encoding::BINARY)
+
+          bzip2.decompress(input_io, decompressed_io)
+
+          # Write decompressed data
+          decompressed_io.rewind
+          output_io.write(decompressed_io.read)
+        end
+
+        private
+
+        # Write BZIP2 header
+        #
+        # @param output [IO] Output stream
+        # @param level [Integer] Compression level (1-9)
+        def write_header(output, level)
+          # BZIP2 magic: "BZh" + block size
+          header = "#{BZIP2_MAGIC}#{level}"
+          output.write(header)
+        end
+
+        # Read BZIP2 header
+        #
+        # @param input [IO] Input stream
+        # @return [Integer] Block size level
+        def read_header(input)
+          magic = input.read(3)
+          unless magic == BZIP2_MAGIC
+            raise Error, "Not a BZIP2 file (invalid magic bytes)"
+          end
+
+          level_char = input.read(1)
+          level = level_char.to_i
+
+          unless level.between?(BLOCK_SIZE_MIN, BLOCK_SIZE_MAX)
+            raise Error, "Invalid BZIP2 block size: #{level_char}"
+          end
+
+          level
+        end
+
+        # Build compression options
+        #
+        # @param level [Integer] Compression level
+        # @return [Object] Compression options
+        def build_compression_options(level)
+          Models::CompressionOptions.new.tap do |opts|
+            opts.level = level
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/cpio/bounded_io.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Cpio
+      # IO wrapper that limits reading to a specific byte count
+      #
+      # Used to read file content from CPIO archives where the file size
+      # is known in advance but the underlying IO stream continues.
+      class BoundedIO
+        attr_reader :length, :remaining
+
+        # Initialize bounded IO
+        #
+        # @param io [IO] Underlying IO stream
+        # @param length [Integer] Maximum bytes to read
+        # @yield Block called when EOF is reached (for reading padding)
+        def initialize(io, length, &eof_callback)
+          @io = io
+          @length = length
+          @remaining = length
+          @eof_callback = eof_callback
+          @eof = false
+        end
+
+        # Read bytes from the IO
+        #
+        # @param size [Integer, nil] Number of bytes to read (nil = remaining)
+        # @return [String, nil] Data read or nil at EOF
+        def read(size = nil)
+          return nil if eof?
+
+          size = @remaining if size.nil?
+          data = @io.read(size)
+          return nil if data.nil?
+
+          @remaining -= data.bytesize
+          eof?
+          data
+        end
+
+        # System read (raises on EOF)
+        #
+        # @param size [Integer] Number of bytes to read
+        # @return [String] Data read
+        # @raise [EOFError] If at end of bounded region
+        def sysread(size)
+          raise EOFError, "end of file reached" if eof?
+
+          read(size)
+        end
+
+        # Check if at end of bounded region
+        #
+        # @return [Boolean] True if no more bytes to read
+        def eof?
+          return false if @remaining.positive?
+          return @eof if @eof
+
+          @eof_callback&.call
+          @eof = true
+        end
+      end
+    end
+  end
+end