omnizip 0.4.7-aarch64-linux

data/lib/omnizip/formats/seven_zip/bcj2_stream_decompressor.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Decompresses BCJ2 multi-stream folders
+      #
+      # BCJ2 archives have 4 separate pack streams that need to be:
+      # 1. Read separately
+      # 2. Decompressed individually (main is LZMA, others are usually COPY)
+      # 3. Combined via BCJ2 decoder
+      class Bcj2StreamDecompressor
+        include Omnizip::Formats::SevenZip::Constants
+
+        # Initialize BCJ2 decompressor
+        #
+        # @param archive_io [IO] Archive file handle
+        # @param folder [Models::Folder] Folder with BCJ2 coder
+        # @param pack_pos [Integer] Base position of packed data
+        # @param pack_sizes [Array<Integer>] Sizes of each pack stream
+        # @param stream_info [Models::StreamInfo] Stream info for unpack sizes
+        def initialize(archive_io, folder, pack_pos, pack_sizes, stream_info)
+          @archive_io = archive_io
+          @folder = folder
+          @pack_pos = pack_pos
+          @pack_sizes = pack_sizes
+          @stream_info = stream_info
+        end
+
+        # Check if a folder contains BCJ2 coder
+        #
+        # @param folder [Models::Folder] Folder to check
+        # @return [Boolean] true if folder has BCJ2
+        def self.bcj2_folder?(folder)
+          folder.coders.any? { |c| c.method_id == FilterId::BCJ2 }
+        end
+
+        # Decompress BCJ2 multi-stream folder
+        #
+        # @param expected_size [Integer] Expected final output size
+        # @return [String] Decompressed and BCJ2-decoded data
+        def decompress(expected_size)
+          # Find BCJ2 coder and compression coder
+          bcj2_coder = @folder.coders.find { |c| c.method_id == FilterId::BCJ2 }
+          compression_coder = find_compression_coder
+
+          raise Omnizip::InvalidArchiveError, "BCJ2 coder not found" unless bcj2_coder
+
+          # Determine stream layout based on folder structure
+          # BCJ2 has 4 input streams: main, call, jump, rc
+          stream_layout = determine_stream_layout(bcj2_coder, compression_coder)
+
+          # Read and decompress each of the 4 streams
+          streams = read_bcj2_streams(stream_layout)
+
+          # Apply BCJ2 decoder
+          bcj2_data = Omnizip::Filters::Bcj2StreamData.new
+          bcj2_data.main = streams[:main]
+          bcj2_data.call = streams[:call]
+          bcj2_data.jump = streams[:jump]
+          bcj2_data.rc = streams[:rc]
+
+          decoder = Omnizip::Filters::Bcj2Decoder.new(bcj2_data)
+          decoder.decode(expected_size)
+        end
+
+        private
+
+        # Find the compression coder (LZMA/LZMA2/etc) in the folder
+        #
+        # @return [Models::CoderInfo, nil] Compression coder
+        def find_compression_coder
+          @folder.coders.find do |c|
+            [MethodId::LZMA, MethodId::LZMA2, MethodId::BZIP2,
+             MethodId::DEFLATE, MethodId::DEFLATE64, MethodId::PPMD].include?(c.method_id)
+          end
+        end
+
+        # Determine how streams are laid out based on folder structure
+        #
+        # Analyzes bind pairs to determine which pack stream feeds which
+        # BCJ2 input, and which coder (if any) decompresses it.
+        #
+        # BCJ2 has 4 inputs: main(0), call(1), jump(2), rc(3)
+        # Each input is either:
+        #   - Bound: fed by another coder's output (needs decompression)
+        #   - Unbound: a direct pack stream (raw data, typically rc)
+        #
+        # @param bcj2_coder [Models::CoderInfo] BCJ2 coder
+        # @param _compression_coder [Models::CoderInfo] (unused, kept for API compat)
+        # @return [Hash] Stream layout specification
+        def determine_stream_layout(_bcj2_coder, _compression_coder)
+          # Compute composite in/out stream base indices for each coder
+          in_bases = []
+          out_bases = []
+          in_pos = 0
+          out_pos = 0
+          @folder.coders.each do |coder|
+            in_bases << in_pos
+            out_bases << out_pos
+            in_pos += coder.num_in_streams
+            out_pos += coder.num_out_streams
+          end
+
+          # Find the BCJ2 coder index and its input stream base
+          bcj2_idx = @folder.coders.index { |c| c.method_id == FilterId::BCJ2 }
+          bcj2_in_base = in_bases[bcj2_idx]
+
+          # BCJ2's 4 input streams: main, call, jump, rc
+          bcj2_in_streams = (0...4).map { |i| bcj2_in_base + i }
+
+          # Build bind map: in_stream -> out_stream
+          bind_map = {}
+          @folder.bind_pairs.each { |pair| bind_map[pair[0]] = pair[1] }
+
+          # Build out_stream -> coder_index map
+          out_to_coder = {}
+          @folder.coders.each_with_index do |coder, ci|
+            coder.num_out_streams.times do |j|
+              out_to_coder[out_bases[ci] + j] = ci
+            end
+          end
+
+          # Map unbound input streams to pack streams using pack_stream_indices
+          # pack_stream_indices[i] = unbound_input_stream for pack stream i
+          # This mapping is NOT necessarily sorted order!
+          unbound_to_pack = {}
+          @folder.pack_stream_indices.each_with_index do |input_stream, pack_idx|
+            unbound_to_pack[input_stream] = pack_idx
+          end
+
+          # For each BCJ2 input, determine its source
+          stream_names = %i[main call jump rc]
+          layout = { type: :generic }
+
+          bcj2_in_streams.each_with_index do |in_stream, i|
+            name = stream_names[i]
+
+            if bind_map.key?(in_stream)
+              # Bound: fed by a coder's output
+              source_out = bind_map[in_stream]
+              source_coder_idx = out_to_coder[source_out]
+              source_coder = @folder.coders[source_coder_idx]
+
+              # Find the source coder's pack stream (its unbound input)
+              source_in_base = in_bases[source_coder_idx]
+              source_pack_in = (source_in_base...(source_in_base + source_coder.num_in_streams))
+                .find do |s|
+                unbound_to_pack.key?(s)
+              end
+              pack_idx = unbound_to_pack[source_pack_in]
+
+              layout[name] =
+                { pack_idx: pack_idx, coder: source_coder,
+                  unpack_idx: source_out }
+            else
+              # Unbound: direct pack stream (no decompression)
+              pack_idx = unbound_to_pack[in_stream]
+              layout[name] = { pack_idx: pack_idx, coder: nil }
+            end
+          end
+
+          layout
+        end
+
+        # Read and decompress BCJ2 streams
+        #
+        # @param layout [Hash] Stream layout specification
+        # @return [Hash] Decompressed stream data
+        def read_bcj2_streams(layout)
+          # Precompute absolute positions for each pack stream
+          pack_positions = []
+          pos = @pack_pos
+          @pack_sizes.each do |size|
+            pack_positions << pos
+            pos += size
+          end
+
+          streams = {}
+
+          %i[main call jump rc].each do |stream_name|
+            spec = layout[stream_name]
+            pack_idx = spec[:pack_idx]
+            pack_size = @pack_sizes[pack_idx] || 0
+
+            # Use absolute position for this pack stream
+            abs_pos = pack_positions[pack_idx]
+            @archive_io.seek(abs_pos)
+            packed_data = @archive_io.read(pack_size)
+
+            # Decompress if needed
+            streams[stream_name] = if spec[:coder]
+                                     unpack_idx = spec[:unpack_idx]
+                                     unpack_size = @folder.unpack_sizes[unpack_idx] if unpack_idx
+                                     decompress_stream(packed_data, spec[:coder], unpack_size)
+                                   else
+                                     # COPY - no decompression needed
+                                     packed_data || "".b
+                                   end
+          end
+
+          streams
+        end
+
+        # Decompress a single stream
+        #
+        # @param packed_data [String] Compressed data
+        # @param coder [Models::CoderInfo] Coder specification
+        # @param unpack_size [Integer, nil] Expected decompressed size
+        # @return [String] Decompressed data
+        def decompress_stream(packed_data, coder, unpack_size = nil)
+          return packed_data if coder.nil?
+
+          algo_sym = CoderChain.algorithm_for_method(coder.method_id)
+          return packed_data unless algo_sym
+
+          algo_class = Omnizip::AlgorithmRegistry.get(algo_sym)
+          raise Omnizip::AlgorithmNotFoundError, "Algorithm not found: #{algo_sym}" unless algo_class
+
+          # Build decoder options
+          options = build_decoder_options(coder, algo_sym)
+
+          # Decompress
+          input_io = StringIO.new(packed_data)
+          output_io = StringIO.new
+          output_io.set_encoding("BINARY")
+
+          decoder = algo_class.new(options)
+
+          # Use provided unpack size or estimate
+          unpack_size ||= packed_data.bytesize * 10
+
+          decoder.decompress(input_io, output_io, size: unpack_size)
+          output_io.string
+        end
+
+        # Build decoder options from coder properties
+        #
+        # @param coder [Models::CoderInfo] Coder with properties
+        # @param algo_sym [Symbol] Algorithm symbol
+        # @return [Hash] Decoder options
+        def build_decoder_options(coder, algo_sym)
+          options = {}
+          properties = coder.properties
+
+          return options if properties.nil? || properties.empty?
+
+          case algo_sym
+          when :lzma2
+            prop_byte = properties.getbyte(0)
+            dict_size = Omnizip::Algorithms::LZMA2::Properties.decode_dict_size(prop_byte)
+            options[:raw_mode] = true
+            options[:dict_size] = dict_size
+          when :lzma
+            if properties.bytesize >= 5
+              props_byte = properties.getbyte(0)
+              dict_size = properties[1, 4].unpack1("V")
+              options[:lzma2_mode] = true
+              options[:lc] = props_byte % 9
+              remainder = props_byte / 9
+              options[:lp] = remainder % 5
+              options[:pb] = remainder / 5
+              options[:dict_size] = dict_size
+            end
+          end
+
+          options
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/coder_chain.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Builds coder chains from .7z folder specifications
+      # Maps method IDs to algorithms and filters, reconstructing the
+      # decompression pipeline
+      class CoderChain
+        include Omnizip::Formats::SevenZip::Constants
+
+        # Build coder chain from folder specification
+        #
+        # @param folder [Models::Folder] Folder specification
+        # @return [Hash] Coder chain configuration
+        # @raise [RuntimeError] if unsupported method encountered
+        def self.build_from_folder(folder)
+          return nil if folder.coders.empty?
+
+          # Find the compression method (not a filter) among coders
+          # Filters like BCJ, BCJ2 have specific method IDs
+          main_coder = find_compression_coder(folder.coders)
+          raise Omnizip::InvalidArchiveError, "No compression method found in folder" unless main_coder
+
+          algorithm = algorithm_for_method(main_coder.method_id)
+
+          # Check for filters (all coders except the compression method)
+          filters = []
+          folder.coders.each do |coder|
+            next if coder == main_coder
+
+            filter = filter_for_method(coder.method_id)
+            filters << filter if filter
+          end
+
+          {
+            algorithm: algorithm,
+            filters: filters,
+            properties: main_coder.properties,
+            unpack_size: folder.unpack_sizes.last,
+          }
+        end
+
+        # Find the compression coder among all coders
+        #
+        # @param coders [Array<Models::CoderInfo>] All coders in the folder
+        # @return [Models::CoderInfo, nil] The compression coder or nil
+        def self.find_compression_coder(coders)
+          # Try to find a known compression method
+          coders.each do |coder|
+            case coder.method_id
+            when MethodId::LZMA, MethodId::LZMA2, MethodId::BZIP2,
+                 MethodId::DEFLATE, MethodId::DEFLATE64, MethodId::PPMD,
+                 MethodId::COPY
+              return coder
+            end
+          end
+
+          # Fall back to last coder if no known compression method found
+          coders.last
+        end
+
+        # Map method ID to algorithm
+        #
+        # @param method_id [Integer] Method ID from .7z file
+        # @return [Symbol] Algorithm identifier
+        # @raise [RuntimeError] if method not supported
+        def self.algorithm_for_method(method_id)
+          case method_id
+          when MethodId::COPY
+            nil # No decompression needed
+          when MethodId::LZMA
+            :lzma
+          when MethodId::LZMA2
+            :lzma2
+          when MethodId::PPMD
+            :ppmd7
+          when MethodId::BZIP2
+            :bzip2
+          when MethodId::DEFLATE
+            :deflate
+          when MethodId::DEFLATE64
+            :deflate64
+          else
+            raise Omnizip::UnsupportedFormatError, "Unsupported compression method: " \
+                                                   "0x#{method_id.to_s(16)}"
+          end
+        end
+
+        # Map method ID to filter
+        #
+        # @param method_id [Integer] Method ID from .7z file
+        # @return [Symbol, nil] Filter identifier or nil
+        def self.filter_for_method(method_id)
+          case method_id
+          when FilterId::BCJ_X86
+            :bcj_x86
+          when FilterId::BCJ_PPC
+            :bcj_ppc
+          when FilterId::BCJ_IA64
+            :bcj_ia64
+          when FilterId::BCJ_ARM
+            :bcj_arm
+          when FilterId::BCJ_ARMT
+            :bcj_armt
+          when FilterId::BCJ_SPARC
+            :bcj_sparc
+          when FilterId::ARM64
+            :bcj_arm64
+          when FilterId::DELTA
+            :delta
+          when FilterId::BCJ2
+            :bcj2
+          end
+        end
+
+        # Create decompressor for coder chain
+        #
+        # @param chain_config [Hash] Chain configuration
+        # @param input_io [IO] Input stream
+        # @return [Object] Decompressor instance
+        def self.create_decompressor(chain_config, input_io)
+          return nil unless chain_config
+          return input_io unless chain_config[:algorithm]
+
+          # Get algorithm
+          algo_class = AlgorithmRegistry.get(chain_config[:algorithm])
+          unless algo_class
+            raise Omnizip::AlgorithmNotFoundError, "Algorithm not found: #{chain_config[:algorithm]}"
+          end
+
+          # Create algorithm instance
+          decompressor = algo_class.new
+          # Pass properties if algorithm supports them
+          # Some algorithms (LZMA2) need properties
+          if chain_config[:properties] && !chain_config[:properties].empty? && decompressor.is_a?(Omnizip::Algorithms::LZMA2)
+            decompressor.properties = chain_config[:properties]
+          end
+
+          # Apply filters if present
+          if chain_config[:filters] && !chain_config[:filters].empty?
+            # Build filter pipeline
+            pipeline = FilterPipeline.new
+            chain_config[:filters].each do |filter_sym|
+              filter_class = FilterRegistry.get(filter_sym)
+              raise Omnizip::UnknownFilterError, "Filter not found: #{filter_sym}" unless filter_class
+
+              pipeline.add_filter(filter_class.new)
+            end
+
+            # Return composite: input -> algorithm -> filters
+            {
+              decompressor: decompressor,
+              pipeline: pipeline,
+              input: input_io,
+            }
+          else
+            # Just algorithm
+            {
+              decompressor: decompressor,
+              pipeline: nil,
+              input: input_io,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/constants.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Constants for .7z archive format
+      # Based on 7-Zip specification
+      module Constants
+        # Archive signature and header
+        SIGNATURE = "7z\xBC\xAF\x27\x1C".b.freeze
+        SIGNATURE_SIZE = 6
+        START_HEADER_SIZE = 32 # 0x20
+        MAJOR_VERSION = 0
+        MINOR_VERSION = 4
+
+        # Property IDs for .7z format structure
+        module PropertyId
+          K_END = 0x00
+          HEADER = 0x01
+          ARCHIVE_PROPERTIES = 0x02
+          ADDITIONAL_STREAMS_INFO = 0x03
+          MAIN_STREAMS_INFO = 0x04
+          FILES_INFO = 0x05
+          PACK_INFO = 0x06
+          UNPACK_INFO = 0x07
+          SUBSTREAMS_INFO = 0x08
+          SIZE = 0x09
+          CRC = 0x0A
+          FOLDER = 0x0B
+          CODERS_UNPACK_SIZE = 0x0C
+          NUM_UNPACK_STREAM = 0x0D
+          EMPTY_STREAM = 0x0E
+          EMPTY_FILE = 0x0F
+          ANTI = 0x10
+          NAME = 0x11
+          CTIME = 0x12
+          ATIME = 0x13
+          MTIME = 0x14
+          WIN_ATTRIB = 0x15
+          COMMENT = 0x16
+          ENCODED_HEADER = 0x17
+          START_POS = 0x18
+          DUMMY = 0x19
+        end
+
+        # Method IDs for compression algorithms
+        module MethodId
+          # Compression methods
+          COPY = 0x00
+          LZMA = 0x030101
+          LZMA2 = 0x21
+          PPMD = 0x030401
+          BZIP2 = 0x040202
+          DEFLATE = 0x040108
+          DEFLATE64 = 0x040109
+
+          # Crypto methods
+          AES = 0x06F10701
+
+          def self.name(id)
+            case id
+            when COPY then "Copy"
+            when LZMA then "LZMA"
+            when LZMA2 then "LZMA2"
+            when PPMD then "PPMd"
+            when BZIP2 then "BZip2"
+            when DEFLATE then "Deflate"
+            when DEFLATE64 then "Deflate64"
+            when AES then "AES256"
+            else "Unknown(0x#{id.to_s(16)})"
+            end
+          end
+        end
+
+        # Filter IDs
+        module FilterId
+          # BCJ filters for executable files
+          BCJ_X86 = 0x03030103
+          BCJ_PPC = 0x03030205
+          BCJ_IA64 = 0x03030401
+          BCJ_ARM = 0x03030501
+          BCJ_ARMT = 0x03030701
+          BCJ_SPARC = 0x03030805
+          ARM64 = 0x03030601
+
+          # BCJ2 filter
+          BCJ2 = 0x0303011B
+
+          # Swap filters for byte order conversion
+          SWAP2 = 0x03030204
+          SWAP4 = 0x03030208
+
+          # Delta filter
+          DELTA = 0x03
+
+          def self.name(id)
+            case id
+            when BCJ_X86 then "BCJ-x86"
+            when BCJ_PPC then "BCJ-PPC"
+            when BCJ_IA64 then "BCJ-IA64"
+            when BCJ_ARM then "BCJ-ARM"
+            when BCJ_ARMT then "BCJ-ARMT"
+            when BCJ_SPARC then "BCJ-SPARC"
+            when DELTA then "Delta"
+            when ARM64 then "BCJ-ARM64"
+            when BCJ2 then "BCJ2"
+            when SWAP2 then "Swap2"
+            when SWAP4 then "Swap4"
+            else "Unknown(0x#{id.to_s(16)})"
+            end
+          end
+
+          def self.bcj_filter?(id)
+            [BCJ_X86, BCJ_PPC, BCJ_IA64, BCJ_ARM, BCJ_ARMT, BCJ_SPARC,
+             ARM64].include?(id)
+          end
+        end
+
+        # Maximum limits
+        MAX_NUM_CODERS = 4
+        MAX_NUM_BONDS = 3
+        MAX_NUM_PACK_STREAMS = 4
+      end
+    end
+  end
+end

data/lib/omnizip/formats/seven_zip/encoded_header.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module SevenZip
+      # Handles 7-Zip encoded headers
+      #
+      # 7-Zip can compress the Next Header metadata with LZMA2 to save space.
+      # This module provides functionality to encode and decode headers.
+      module EncodedHeader
+        include Omnizip::Formats::SevenZip::Constants
+
+        module_function
+
+        # Encode next header with LZMA2 compression
+        #
+        # @param header_data [String] Uncompressed header data
+        # @return [String] Encoded header property with compressed data
+        def encode(header_data)
+          # Compress header with LZMA2
+          compressed = compress_header(header_data)
+
+          # Build encoded header property
+          encoded = String.new(encoding: "BINARY")
+          encoded << [PropertyId::ENCODED_HEADER].pack("C")
+
+          # Write pack info for compressed header
+          encoded << [PropertyId::PACK_INFO].pack("C")
+          encoded << encode_uint64(0)  # Pack position
+          encoded << encode_uint64(1)  # Number of pack streams
+
+          # Write size
+          encoded << [PropertyId::SIZE].pack("C")
+          encoded << encode_uint64(compressed.bytesize)
+
+          encoded << [PropertyId::K_END].pack("C")
+
+          # Write coder info (LZMA2)
+          encoded << [PropertyId::UNPACK_INFO].pack("C")
+          encoded << [PropertyId::FOLDER].pack("C")
+          encoded << encode_uint64(1)  # Number of folders
+          encoded << [0].pack("C")     # External flag (0 = inline)
+
+          # Number of coders
+          encoded << encode_uint64(1)
+
+          # Coder info for LZMA2
+          # Method ID: LZMA2 = 0x21
+          encoded << [1].pack("C") # Main byte (1 byte for ID, no properties)
+          encoded << [0x21].pack("C") # LZMA2 method ID
+
+          # Unpack size
+          encoded << [PropertyId::CODERS_UNPACK_SIZE].pack("C")
+          encoded << encode_uint64(header_data.bytesize)
+
+          encoded << [PropertyId::K_END].pack("C")
+
+          # Append compressed data
+          encoded << compressed
+
+          encoded
+        end
+
+        # Compress header data with LZMA2
+        #
+        # @param header_data [String] Uncompressed header
+        # @return [String] Compressed header
+        def compress_header(header_data)
+          # Use 7-Zip SDK LZMA2 encoder for 7-Zip format
+          encoder = Omnizip::Implementations::SevenZip::LZMA2::Encoder.new(
+            dict_size: 4096, # Small dictionary for headers
+            lc: 3,
+            lp: 0,
+            pb: 2,
+            standalone: false, # No property byte
+          )
+
+          encoder.encode(header_data)
+        end
+
+        # Encode unsigned 64-bit integer in 7-Zip variable-length format
+        #
+        # @param value [Integer] Value to encode
+        # @return [String] Encoded bytes
+        def encode_uint64(value)
+          return [value].pack("C") if value < 0x80
+
+          result = String.new(encoding: "BINARY")
+          shift = 0
+
+          loop do
+            byte = value & 0x7F
+            value >>= 7
+
+            if value.zero?
+              result << [byte].pack("C")
+              break
+            else
+              result << [byte | 0x80].pack("C")
+            end
+
+            shift += 7
+          end
+
+          result
+        end
+      end
+    end
+  end
+end