omnizip 0.4.7-arm-linux

data/lib/omnizip/algorithms/lzma2/lzma2_chunk.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Algorithms
+    class LZMA2 < Algorithm
+      # LZMA2 Chunk structure using Array#pack for binary serialization
+      class LZMA2Chunk
+        TYPE_END = :end
+        TYPE_UNCOMPRESSED = :uncompressed
+        TYPE_COMPRESSED = :compressed
+
+        attr_reader :chunk_type, :uncompressed_data, :compressed_data,
+                    :properties, :control_byte
+
+        # Factory method for end marker
+        def self.end_chunk
+          new(
+            chunk_type: TYPE_END,
+            uncompressed_data: "",
+            compressed_data: "",
+            need_dict_reset: false,
+            need_state_reset: false,
+            need_props: false,
+          )
+        end
+
+        def initialize(chunk_type:, need_dict_reset:, need_state_reset:,
+                       need_props:, uncompressed_data: "",
+                       compressed_data: "", properties: nil,
+                       compressed_size: nil)
+          # Validate chunk_type
+          valid_types = [TYPE_END, TYPE_UNCOMPRESSED, TYPE_COMPRESSED]
+          unless valid_types.include?(chunk_type)
+            raise ArgumentError,
+                  "Invalid chunk_type: #{chunk_type.inspect}. " \
+                  "Must be :end, :uncompressed, or :compressed"
+          end
+
+          @chunk_type = chunk_type
+          @uncompressed_data = uncompressed_data
+          @compressed_data = compressed_data
+          # For XZ format, compressed_size excludes flush bytes
+          # For standalone LZMA2, compressed_size includes all bytes
+          @compressed_size = compressed_size || @compressed_data.bytesize
+          @properties = properties
+          @need_dict_reset = need_dict_reset
+          @need_state_reset = need_state_reset
+          @need_props = need_props
+
+          @control_byte = build_control_byte if chunk_type != TYPE_END
+        end
+
+        # Serialize to binary format
+        def to_bytes
+          case @chunk_type
+          when TYPE_END
+            [0x00].pack("C")
+          when TYPE_UNCOMPRESSED
+            serialize_uncompressed
+          when TYPE_COMPRESSED
+            serialize_compressed
+          end
+        end
+
+        private
+
+        def build_control_byte
+          case @chunk_type
+          when TYPE_COMPRESSED
+            # XZ Utils LZMA2 compressed chunk format:
+            # Base is 0x80 (bit 7 = 1 for compressed)
+            # Bits 6-5 encode reset state (shifted left by 5):
+            #   3 << 5 = 0x60 = dict reset + state reset + properties
+            #   2 << 5 = 0x40 = state reset + properties
+            #   1 << 5 = 0x20 = state reset only
+            #   0 << 5 = 0x00 = no reset (no properties)
+            #
+            # Control byte format: 0x80 + (reset_type << 5)
+            # High 5 bits of (uncompressed_size - 1) are added later in serialize_compressed
+
+            control = if @need_props
+                        if @need_dict_reset
+                          0x80 + (3 << 5) # 0xE0 = dict reset + state reset + properties
+                        elsif @need_state_reset
+                          0x80 + (2 << 5) # 0xC0 = state reset + properties
+                        else
+                          # This shouldn't happen - if need_props, we need some reset
+                          0x80 + (2 << 5) # Default to state reset + properties
+                        end
+                      elsif @need_state_reset
+                        0x80 + (1 << 5)
+                      else
+                        0x80 # 0x80 = no reset
+                      end
+
+            # DEBUG: Print control byte calculation
+            if ENV["DEBUG_CHUNK"]
+              warn "LZMA2Chunk build_control_byte: need_props=#{@need_props}, need_dict_reset=#{@need_dict_reset}, need_state_reset=#{@need_state_reset}, control=0x#{control.to_s(16)}"
+            end
+
+            control
+          when TYPE_UNCOMPRESSED
+            # XZ Utils LZMA2 uncompressed chunk format:
+            # Control byte is simply 1 or 2 (NOT complex bit encoding!)
+            # 1 = dictionary reset
+            # 2 = no dictionary reset
+            if @need_dict_reset
+              1
+            else
+              2
+            end
+          end
+        end
+
+        def serialize_uncompressed
+          size = @uncompressed_data.bytesize - 1
+
+          # LZMA2 uncompressed chunk format (matches XZ Utils lzma2_encoder.c lzma2_header_uncompressed):
+          # 1 byte: control (1 = dict reset, 2 = no reset)
+          # 2 bytes: Uncompressed Size Minus One in BIG-ENDIAN
+          # N bytes: uncompressed data
+          [
+            @control_byte,              # Control byte (1 or 2)
+            (size >> 8) & 0xFF,         # Size high byte (BIG-ENDIAN)
+            size & 0xFF,                # Size low byte (BIG-ENDIAN)
+          ].pack("CCC") + @uncompressed_data
+        end
+
+        def serialize_compressed
+          uncomp_size = @uncompressed_data.bytesize - 1
+          comp_size = @compressed_size - 1
+
+          # Add high 5 bits to control byte
+          high_bits = ((uncomp_size >> 16) & 0x1F)
+          control = @control_byte | high_bits
+
+          # DEBUG: Print final control byte calculation
+          if ENV["DEBUG_CHUNK"]
+            warn "LZMA2Chunk serialize_compressed: @control_byte=0x#{@control_byte.to_s(16)}, high_bits=0x#{high_bits.to_s(16)}, final_control=0x#{control.to_s(16)}"
+            warn "  uncomp_size=#{@uncompressed_data.bytesize} (uncomp_size-1=#{uncomp_size}), comp_size=#{@compressed_size}"
+          end
+
+          # XZ Utils LZMA2 compressed chunk format (matches lzma2_encoder.c lzma2_header_lzma):
+          # 1 byte: control + high 5 bits of (uncompressed_size - 1)
+          # 2 bytes: low 16 bits of (uncompressed_size - 1) in BIG-ENDIAN
+          # 2 bytes: (compressed_size - 1) in BIG-ENDIAN
+          header = [
+            control,
+            (uncomp_size >> 8) & 0xFF, # Uncompressed size mid byte (BIG-ENDIAN)
+            uncomp_size & 0xFF,          # Uncompressed size low byte (BIG-ENDIAN)
+            (comp_size >> 8) & 0xFF,     # Compressed size high byte (BIG-ENDIAN)
+            comp_size & 0xFF,            # Compressed size low byte (BIG-ENDIAN)
+          ].pack("CCCCC")
+
+          # The properties byte is only present when the control byte
+          # announces it (reset level >= 2, i.e. 0xC0/0xE0). Writing it for
+          # plain continuation chunks (0x80) desynchronizes the decoder,
+          # which does not expect a byte there.
+          prop_bytes = @need_props && @properties ? [@properties].pack("C") : ""
+          header + prop_bytes + @compressed_data
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma2/properties.rb

@@ -0,0 +1,179 @@
+# 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 LZMA2
+      # LZMA2 Properties - handles dictionary size encoding/decoding
+      #
+      # The LZMA2 format uses a single property byte that encodes the
+      # dictionary size. This is more compact than LZMA's multiple
+      # property bytes.
+      #
+      # Dictionary size encoding formula:
+      #   dictSize = (2 | (props & 1)) << (props / 2 + 11)
+      #
+      # This gives sizes from 4KB (props=0) to 4GB (props=40)
+      #
+      # Note: In XZ format, the LZMA2 filter properties byte contains ONLY
+      # the dictionary size encoding. The lc/lp/pb parameters are encoded
+      # in the LZMA chunk properties (inside the compressed data).
+      class Properties
+        include LZMA2Const
+
+        attr_reader :dict_size, :prop_byte
+
+        # Initialize properties from dictionary size
+        #
+        # @param dict_size [Integer] Dictionary size in bytes
+        def initialize(dict_size)
+          @dict_size = validate_dict_size(dict_size)
+          @prop_byte = encode_dict_size(@dict_size)
+        end
+
+        # Create properties from property byte
+        #
+        # @param prop_byte [Integer] Encoded property byte
+        # @return [Properties] New properties instance
+        def self.from_byte(prop_byte)
+          validate_prop_byte(prop_byte)
+          dict_size = decode_dict_size(prop_byte)
+          new(dict_size)
+        end
+
+        # Encode dictionary size to property byte
+        #
+        # @param dict_size [Integer] Dictionary size
+        # @return [Integer] Property byte value
+        def encode_dict_size(dict_size)
+          # Find the smallest prop value that gives >= dict_size
+          # Valid range for property byte is 0-40 (per XZ spec)
+          (0..40).each do |prop|
+            size = self.class.decode_dict_size(prop)
+            return prop if size >= dict_size
+          end
+
+          # If we couldn't find a suitable prop, use maximum
+          40
+        end
+
+        # Decode property byte to dictionary size
+        #
+        # XZ Utils formula from lzma_lzma2_props_decode (lzma2_decoder.c:290-302):
+        #   dict_size = (2 | (props & 1)) << (props / 2 + 11)
+        #
+        # For even props: dict_size = 2 * 2^((props/2) + 11) = 2^((props/2) + 12)
+        # For odd props: dict_size = 3 * 2^((props-1)/2 + 11)
+        #
+        # @param prop [Integer] Property byte
+        # @return [Integer] Dictionary size in bytes
+        def self.decode_dict_size(prop)
+          # XZ Utils formula: dict_size = (2 | (prop & 1)) << (prop / 2 + 11)
+          base = 2 | (prop & 1)
+          base << ((prop / 2) + 11)
+        end
+
+        # Encode properties to property byte
+        # This is for standalone LZMA2 files where the property byte
+        # encodes both dictionary size and lc/lp/pb parameters
+        #
+        # @param dict_size [Integer] Dictionary size
+        # @param lc [Integer] Literal context bits
+        # @param lp [Integer] Literal position bits
+        # @param pb [Integer] Position bits
+        # @return [Integer] Property byte value
+        def self.encode(dict_size, _lc = 3, _lp = 0, _pb = 2)
+          # For standalone LZMA2 files, we only encode the dictionary size
+          # The lc/lp/pb parameters are encoded in the LZMA chunk properties instead
+          validate_prop_byte_range(dict_size)
+          encode_dict_size_to_byte(dict_size)
+        end
+
+        # Encode dictionary size to property byte
+        #
+        # @param dict_size [Integer] Dictionary size
+        # @return [Integer] Property byte value
+        def self.encode_dict_size_to_byte(dict_size)
+          # Find the smallest prop value that gives >= dict_size
+          (0..40).each do |prop|
+            size = decode_dict_size(prop)
+            return prop if size >= dict_size
+          end
+          40
+        end
+
+        # Validate dictionary size for property byte encoding
+        #
+        # @param size [Integer] Dictionary size to validate
+        # @raise [ArgumentError] If size is invalid
+        def self.validate_prop_byte_range(size)
+          unless size.between?(DICT_SIZE_MIN, DICT_SIZE_MAX)
+            raise ArgumentError,
+                  "Dictionary size must be between #{DICT_SIZE_MIN} " \
+                  "and #{DICT_SIZE_MAX}"
+          end
+        end
+
+        # Get the actual dictionary size (may differ from requested)
+        #
+        # @return [Integer] Actual dictionary size (capped at 64MB to prevent memory exhaustion)
+        def actual_dict_size
+          # Cap at 64MB to prevent memory exhaustion from malformed files
+          max_dict = 64 * 1024 * 1024
+          [self.class.decode_dict_size(@prop_byte), max_dict].min
+        end
+
+        private
+
+        # Validate dictionary size
+        #
+        # @param size [Integer] Dictionary size to validate
+        # @return [Integer] Validated size
+        # @raise [ArgumentError] If size is invalid
+        def validate_dict_size(size)
+          # LZMA2 practical maximum is 2GB due to implementation limitations
+          # The spec allows up to 4GB, but practical limits are lower
+          # Maximum is (1 << 31) - 1 due to signed 32-bit integer limits
+          max_size = [DICT_SIZE_MAX, (1 << 31) - 1].min
+          unless size.between?(DICT_SIZE_MIN, max_size)
+            raise ArgumentError,
+                  "Dictionary size must be between #{DICT_SIZE_MIN} " \
+                  "and #{max_size}"
+          end
+          size
+        end
+
+        # Validate property byte
+        #
+        # @param prop [Integer] Property byte to validate
+        # @return [void]
+        # @raise [ArgumentError] If property byte is invalid
+        def self.validate_prop_byte(prop)
+          return if prop.between?(0, 40)
+
+          raise ArgumentError,
+                "Property byte must be between 0 and 40"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma2/simple_lzma2_encoder.rb

@@ -0,0 +1,122 @@
+# 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 "stringio"
+
+module Omnizip
+  module Algorithms
+    class LZMA2 < Algorithm
+      # Simple LZMA2 encoder using XzEncoder internally
+      #
+      # This encoder uses the working XzEncoder for LZMA compression
+      # and wraps the result in proper LZMA2 chunks.
+      #
+      # For 7-Zip format compatibility, we need to produce LZMA2 chunks
+      # without a leading property byte (raw mode).
+      class SimpleLZMA2Encoder
+        # Maximum uncompressed size per LZMA2 chunk (2MB)
+        UNCOMPRESSED_MAX = 1 << 21
+
+        # Initialize the encoder
+        # @param dict_size [Integer] Dictionary size (default: 8MB)
+        # @param lc [Integer] Literal context bits (default: 3)
+        # @param lp [Integer] Literal position bits (default: 0)
+        # @param pb [Integer] Position bits (default: 2)
+        # @param standalone [Boolean] If true, write property byte at start
+        def initialize(
+          dict_size: 8 * 1024 * 1024,
+          lc: 3,
+          lp: 0,
+          pb: 2,
+          standalone: true
+        )
+          @dict_size = dict_size
+          @lc = lc
+          @lp = lp
+          @pb = pb
+          @standalone = standalone
+        end
+
+        # Encode data into LZMA2 format
+        # @param input_data [String] Input data to compress
+        # @return [String] LZMA2 compressed data
+        def encode(input_data)
+          output = StringIO.new
+          output.set_encoding(Encoding::BINARY)
+
+          # Write property byte if standalone
+          # LZMA2 property byte encodes dictionary size
+          if @standalone
+            prop_byte = encode_dict_size(@dict_size)
+            output.putc(prop_byte)
+          end
+
+          # Use XZ Utils LZMA2 encoder for proper LZMA2 encoding (no EOS marker)
+          # Pass standalone: false since SimpleLZMA2Encoder handles property byte
+          encoder = Omnizip::Implementations::XZUtils::LZMA2::Encoder.new(
+            dict_size: @dict_size,
+            lc: @lc,
+            lp: @lp,
+            pb: @pb,
+            standalone: false,
+          )
+
+          # Encode data - returns LZMA2 data as String (includes end marker)
+          encoded = encoder.encode(input_data)
+
+          # Write encoded data to output
+          output.write(encoded)
+
+          output.string
+        end
+
+        private
+
+        # Encode dictionary size to LZMA2 property byte
+        # @param dict_size [Integer] Dictionary size
+        # @return [Integer] Property byte (0-40)
+        def encode_dict_size(dict_size)
+          # Clamp to valid range
+          d = [dict_size, LZMA2Const::DICT_SIZE_MIN].max
+
+          # Calculate log2 of dict_size
+          log2_size = 0
+          temp = d
+          while temp > 1
+            log2_size += 1
+            temp >>= 1
+          end
+
+          # Encoding formula for power-of-2 sizes:
+          # d = 2 * (log2_size - 12)
+          if d == (1 << log2_size)
+            # Exact power of 2
+            [(log2_size - 12) * 2, 40].min
+          else
+            # Between 2^n and 2^n + 2^(n-1), use odd encoding
+            [((log2_size - 12) * 2) + 1, 40].min
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/lzma2/xz_encoder_adapter.rb

@@ -0,0 +1,85 @@
+# 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 "stringio"
+
+module Omnizip
+  module Algorithms
+    # Adapter for XZ Encoder to work with LZMA2 chunking
+    #
+    # Wraps the pure Ruby XZ encoder to provide LZMA2-compatible interface
+    # for chunked encoding with size limits.
+    class LZMA2XzEncoderAdapter
+      # Initialize XZ encoder adapter
+      #
+      # @param options [Hash] Encoding options
+      # @option options [Integer] :lc Literal context bits (default 3)
+      # @option options [Integer] :lp Literal position bits (default 0)
+      # @option options [Integer] :pb Position bits (default 2)
+      # @option options [Integer] :nice_len Nice match length (default 32)
+      # @option options [Integer] :dict_size Dictionary size (default 8MB)
+      def initialize(options = {})
+        @options = options
+        @lc = options[:lc] || 3
+        @lp = options[:lp] || 0
+        @pb = options[:pb] || 2
+      end
+
+      # Encode data chunk
+      #
+      # @param data [String] Input data to encode
+      # @param limit [Integer, nil] Optional output size limit
+      # @return [String] Encoded data
+      def encode_chunk(data, _limit = nil)
+        output = StringIO.new
+        encoder = LZMA::XzEncoder.new(@options)
+
+        # Encode with optional size limit
+        # XZ encoder returns bytes written to output
+        encoder.encode(data, output)
+
+        # Return the encoded data string
+        output.string
+      end
+
+      # Get LZMA properties byte
+      #
+      # Encodes lc, lp, pb into single byte using formula:
+      # (pb * 5 + lp) * 9 + lc
+      #
+      # @return [Integer] Properties byte (0x00-0xFF)
+      def properties
+        (((@pb * 5) + @lp) * 9) + @lc
+      end
+
+      # Get dictionary size
+      #
+      # @return [Integer] Dictionary size in bytes
+      def dict_size
+        @options[:dict_size] || (1 << 23) # 8MB default
+      end
+    end
+
+    # Backward compatibility alias
+    XzEncoderAdapter = LZMA2XzEncoderAdapter unless defined?(XzEncoderAdapter)
+  end
+end

data/lib/omnizip/algorithms/lzma2.rb

@@ -0,0 +1,133 @@
+# 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 "stringio"
+
+module Omnizip
+  module Algorithms
+    # LZMA2 compression algorithm
+    # Improved version of LZMA with chunked format for better streaming
+    class LZMA2 < Algorithm
+      # Nested classes - autoloaded
+      autoload :Constants, "omnizip/algorithms/lzma2/constants"
+      autoload :Properties, "omnizip/algorithms/lzma2/properties"
+      autoload :LZMA2Chunk, "omnizip/algorithms/lzma2/lzma2_chunk"
+      autoload :Encoder, "omnizip/algorithms/lzma2/encoder"
+      autoload :XzEncoderAdapter, "omnizip/algorithms/lzma2/xz_encoder_adapter"
+      autoload :LZMA2XzEncoderAdapter,
+               "omnizip/algorithms/lzma2/xz_encoder_adapter"
+      autoload :ChunkManager, "omnizip/algorithms/lzma2/chunk_manager"
+      autoload :SimpleLZMA2Encoder,
+               "omnizip/algorithms/lzma2/simple_lzma2_encoder"
+    end
+  end
+end
+
+module Omnizip
+  module Algorithms
+    class LZMA2 < Algorithm
+      class << self
+        # Get algorithm metadata
+        #
+        # @return [Models::AlgorithmMetadata] Algorithm metadata
+        def metadata
+          Models::AlgorithmMetadata.new.tap do |meta|
+            meta.name = "lzma2"
+            meta.description = "LZMA2 compression with improved chunking format for better streaming"
+            meta.version = "1.0.0"
+            meta.supports_streaming = true
+          end
+        end
+      end
+
+      def initialize(options = {})
+        super()
+        @dict_size = options[:dict_size] || (8 * 1024 * 1024) # 8 MB default
+        @lc = options[:lc] || 3
+        @lp = options[:lp] || 0
+        @pb = options[:pb] || 2
+        @level = options[:level] || 6
+        @raw_mode = options[:raw_mode] # For 7-Zip format (no property byte)
+      end
+
+      # Compress data using LZMA2
+      def compress(input, output, options = {})
+        # For 7-Zip format, use raw_mode (no property byte in data stream)
+        # Standalone LZMA2 files include a property byte
+        standalone = options.fetch(:standalone, true)
+        options.fetch(:raw_mode, !standalone)
+
+        encoder = LZMA2Encoder.new(
+          dict_size: @dict_size,
+          lc: @lc,
+          lp: @lp,
+          pb: @pb,
+          standalone: standalone, # Write property byte only for standalone files
+        )
+
+        # Read input
+        input_data = Omnizip::IO::Source.for(input).read
+
+        # Encode with LZMA2
+        compressed = encoder.encode(input_data)
+
+        # Write to output
+        Omnizip::IO::Sink.for(output).write(compressed)
+      end
+
+      # Decompress LZMA2 data
+      def decompress(input, output, options = {})
+        # Read input data
+        input_data = Omnizip::IO::Source.for(input).read
+        input_stream = StringIO.new(input_data)
+        input_stream.set_encoding(Encoding::BINARY)
+
+        # Determine raw_mode:
+        # - For 7-Zip format: raw_mode=true, dict_size from coder properties
+        # - For standalone LZMA2 files: raw_mode=false, dict_size from property byte
+        raw_mode = options.fetch(:raw_mode, @raw_mode || false)
+        dict_size = options.fetch(:dict_size, @dict_size)
+
+        # Create decoder using XZ Utils implementation
+        decoder = Omnizip::Implementations::XZUtils::LZMA2::Decoder.new(
+          input_stream,
+          raw_mode: raw_mode,
+          dict_size: dict_size,
+        )
+
+        # Decode LZMA2 data
+        decompressed = decoder.decode_stream
+
+        # Write to output
+        Omnizip::IO::Sink.for(output).write(decompressed)
+      end
+
+      # Encode dictionary size as single byte for LZMA2 properties
+      def self.encode_dict_size(dict_size)
+        LZMA2Encoder.encode_dict_size(dict_size)
+      end
+    end
+  end
+end
+
+# Auto-register LZMA2 in algorithm registry
+Omnizip::Algorithms::LZMA2.register_algorithm