omnizip 0.3.8 → 0.3.10

data/lib/omnizip/algorithms/lzma/range_decoder.rb

@@ -33,7 +33,7 @@ module Omnizip
       # extract the original bit values. It maintains a code value
       # that represents the current position within the range.
       class RangeDecoder < RangeCoder
-        attr_reader :code
+        attr_reader :code, :init_bytes_remaining, :range, :stream
 
         # Initialize the range decoder
         #
@@ -48,13 +48,6 @@ module Omnizip
 
         # Update the input stream (for LZMA2 multi-chunk streams)
         #
-        # When processing LZMA2 chunks, we need to update the stream
-        # reference for each new chunk while preserving the range decoder
-        # state (range, code) across chunks.
-        #
-        # XZ Utils pattern: The range coder uses a buffer pointer that's
-        # updated for each chunk, while rc_reset() resets range/code.
-        #
         # @param new_stream [IO] New input stream
         # @return [void]
         def update_stream(new_stream)
@@ -63,167 +56,77 @@ module Omnizip
 
         # Decode a single bit using a probability model
         #
-        # The range is split based on the bit's probability,
-        # and the code value determines which portion contains
-        # the actual bit value.
-        #
-        # XZ Utils pattern (rc_if_0): normalize BEFORE bound calculation
-        # See: /Users/mulgogi/src/external/xz/src/liblzma/rangecoder/range_decoder.h:181-184
+        # This is the hottest method (~5 billion calls for a 600MB file).
+        # normalize() and model.update() are inlined to eliminate method dispatch.
         #
         # @param model [BitModel] The probability model for this bit
         # @return [Integer] The decoded bit value (0 or 1)
         def decode_bit(model)
-          # XZ Utils: rc_normalize FIRST, then calculate bound
-          normalize
-          bound = (@range >> 11) * model.probability
-
-          # DEBUG: Trace model updates to find probability corruption
-          trace_model_updates = ENV.fetch("TRACE_MODEL_UPDATES", nil)
-          prob_before = model.probability if trace_model_updates
-
-          # DEBUG: Trace is_rep bit decoding
-          trace_is_rep = ENV.fetch("TRACE_IS_REP_BITS",
-                                   nil) && (bound > 1_000_000)
-
-          if trace_is_rep
-            puts "  [RangeDecoder.decode_bit] BEFORE: range=#{@range}, code=#{@code}, bound=#{bound}, prob=#{model.probability}"
-          end
-
-          # DEBUG: Trace model selection at dict_full=227
-          if ENV["TRACE_MODEL_SELECTION"]
-            begin
-              ObjectSpace.each_object(Omnizip::Algorithms::XzUtilsDecoder) do |decoder|
-                dict_full = decoder.instance_variable_get(:@dict_full)
-                if dict_full && dict_full >= 220 && dict_full <= 235
-                  pos = decoder.instance_variable_get(:@pos)
-                  state = decoder.instance_variable_get(:@state)
-                  puts "    [decode_bit] dict_full=#{dict_full}, pos=#{pos}, state=#{state}"
-                  puts "    [decode_bit] model.object_id=#{model.object_id}, prob=#{model.probability}"
-                  puts "    [decode_bit] range=0x#{@range.to_s(16)}, code=0x#{@code.to_s(16)}, bound=0x#{bound.to_s(16)}"
-                  $stderr.flush
-                end
-                break
-              end
-            rescue StandardError => e
-              # Context not available
-              puts "    [decode_bit] ERROR: #{e.message}"
-              $stderr.flush
+          # Inline normalize: only the hot path (range < TOP check)
+          # Init bytes are handled eagerly in reset(), not here
+          if @range < 0x01000000
+            @range <<= 8
+            byte = @stream.getbyte
+            if byte.nil?
+              raise Omnizip::DecompressionError,
+                    "Truncated LZMA stream during range decoder normalization"
             end
-          end
-
-          # DEBUG: Trace decode_bit for lit_state=96 literal decoding
-          if ENV["TRACE_DECODE_BIT_LIT96"]
-            puts "    decode_bit: range=0x#{@range.to_s(16)}, code=0x#{@code.to_s(16)}, prob=#{model.probability}, bound=0x#{bound.to_s(16)}, code<bound?=#{@code < bound}"
-          end
 
-          # DEBUG: Trace decode_bit for specific problematic state
-          if ENV.fetch("TRACE_SPECIFIC_DECODE",
-                       nil) && @range == 0x40000000 && @code == 0x21407d82
-            puts "    === CRITICAL DECODE_BIT (MATCHED LITERAL) ==="
-            puts "    BEFORE: range=0x#{@range.to_s(16)} (#{@range})"
-            puts "    BEFORE: code=0x#{@code.to_s(16)} (#{@code})"
-            puts "    probability=#{model.probability}"
-            puts "    bound=0x#{bound.to_s(16)} (#{bound})"
-            puts "    range >> 11 = 0x#{(@range >> 11).to_s(16)} (#{@range >> 11})"
-            puts "    (range >> 11) * probability = 0x#{((@range >> 11) * model.probability).to_s(16)} (#{(@range >> 11) * model.probability})"
-            puts "    code < bound? #{@code < bound}"
-            puts "    result should be: #{@code < bound ? 0 : 1}"
-            puts "    =========================================="
+            @code = ((@code << 8) | byte) & 0xFFFFFFFF
           end
 
-          # DEBUG: Trace decode_bit for model_index=257 (the problematic one)
-          if ENV["TRACE_DECODE_BIT_257"]
-            # We need to know which model is being used
-            # Unfortunately, we don't have direct access to the model_index here
-            puts "    [decode_bit] range=0x#{@range.to_s(16)}, code=0x#{@code.to_s(16)}, prob=#{model.probability}, bound=0x#{bound.to_s(16)}, code<bound?=#{@code < bound}, result=#{@code < bound ? 0 : 1}"
-          end
+          prob = model.probability
+          bound = (@range >> 11) * prob
 
           if @code < bound
             @range = bound
-            model.update(0)
-            if trace_model_updates && prob_before != model.probability
-              puts "    [decode_bit] model UPDATE: #{prob_before} -> #{model.probability} (bit=0, object_id=#{model.object_id})"
-            end
-            if trace_is_rep
-              puts "  [RangeDecoder.decode_bit] AFTER (bit=0): range=#{@range}, code=#{@code}"
-            end
+            # Inline model.update(0): prob += (2048 - prob) >> 5
+            model.probability = prob + ((2048 - prob) >> 5)
             0
           else
             @code -= bound
             @range -= bound
-            model.update(1)
-            if trace_model_updates && prob_before != model.probability
-              puts "    [decode_bit] model UPDATE: #{prob_before} -> #{model.probability} (bit=1, object_id=#{model.object_id})"
-            end
-            if trace_is_rep
-              puts "  [RangeDecoder.decode_bit] AFTER (bit=1): range=#{@range}, code=#{@code}"
-            end
+            # Inline model.update(1): prob -= prob >> 5
+            model.probability = prob - (prob >> 5)
             1
           end
         end
 
         # Decode bits directly without using probability model
         #
-        # This is used for decoding values with uniform distribution
-        # where all bit values are equally likely.
-        #
         # @param num_bits [Integer] Number of bits to decode
         # @return [Integer] The decoded value
         def decode_direct_bits(num_bits)
           result = 0
-          trace_this = (num_bits == 25)
-          iteration = 0
-
-          if trace_this
-            begin
-              warn "    decode_direct_bits START: num_bits=#{num_bits}"
-              warn "      BEFORE: range=#{@range.inspect}, code=#{@code.inspect}"
-              $stderr.flush
-            rescue StandardError => e
-              warn "      ERROR in trace: #{e.message}"
-              $stderr.flush
-            end
-          end
-
-          begin
-            num_bits.downto(1) do |_i|
-              iteration += 1
-              normalize
-              @range >>= 1
 
-              bit = @code >= @range ? 1 : 0
-              if trace_this && iteration <= 3 # Only first 3 iterations
-                warn "      [#{iteration}/#{num_bits}] range=#{@range.inspect}, code=#{@code.inspect}, bit=#{bit}, result=#{result}"
-                $stderr.flush
+          num_bits.downto(1) do |_i|
+            # Inline normalize
+            if @range < 0x01000000
+              @range <<= 8
+              byte = @stream.getbyte
+              if byte.nil?
+                raise Omnizip::DecompressionError,
+                      "Truncated LZMA stream during range decoder normalization"
               end
 
-              if bit == 1
-                @code -= @range
-                result = (result << 1) | 1
-              else
-                result = (result << 1) | 0
-              end
+              @code = ((@code << 8) | byte) & 0xFFFFFFFF
             end
-          rescue StandardError => e
-            warn "      ERROR in iteration #{iteration}: #{e.message}"
-            warn "      range=#{@range.inspect}, code=#{@code.inspect}"
-            $stderr.flush
-            raise
-          end
+            @range >>= 1
+
+            bit = @code >= @range ? 1 : 0
 
-          if trace_this
-            warn "      AFTER #{iteration} iterations: result=#{result}"
-            $stderr.flush
+            if bit == 1
+              @code -= @range
+              result = (result << 1) | 1
+            else
+              result = (result << 1) | 0
+            end
           end
 
           result
         end
 
-        # Decode a cumulative frequency value
-        #
-        # This is used by PPMd for decoding symbols based on their
-        # frequency distribution. Returns the cumulative frequency
-        # that can be mapped back to a symbol.
+        # Decode a cumulative frequency value (PPMd)
         #
         # @param total_freq [Integer] Total frequency of all symbols in context
         # @return [Integer] The cumulative frequency value
@@ -235,9 +138,6 @@ module Omnizip
 
         # Normalize after decoding a symbol with frequency
         #
-        # After using decode_freq to get the cumulative frequency,
-        # call this to update the range decoder state.
-        #
         # @param cum_freq [Integer] Cumulative frequency of decoded symbol
         # @param freq [Integer] Frequency of decoded symbol
         # @param total_freq [Integer] Total frequency of all symbols
@@ -253,144 +153,84 @@ module Omnizip
 
         # Decode bits directly using a base value (XZ Utils rc_direct pattern)
         #
-        # This method implements the XZ Utils rc_direct macro which is used
-        # for decoding distance values in slots 14+. The pattern matches
-        # XZ Utils' implementation in rangecoder/range_decoder.h:366-375.
-        #
-        # XZ Utils rc_direct behavior (from C macro):
-        # - dest = (dest << 1) + 1 (unconditionally)
-        # - Normalize range, halve it, subtract from code
-        # - bound = 0 - (code >> 31) extracts sign bit
-        #   - If code >= range (bit=1): sign=0, bound=0, dest stays at (dest << 1) + 1
-        #   - If code < range (bit=0): sign=1, bound=-1, dest = (dest << 1) + 1 - 1 = dest << 1
-        # - dest += bound
-        # - code += range & bound (restore code if bit=0)
-        #
-        # In Ruby (without unsigned wraparound), we explicitly check if code >= range
-        # and undo the +1 if the bit is 0.
-        #
         # @param num_bits [Integer] Number of bits to decode
         # @param base [Integer] Base value to start from (2 or 3 for distances)
         # @return [Integer] The decoded value
         def decode_direct_bits_with_base(num_bits, base)
           result = base
-          # DEBUG: Trace for slot=40 (num_bits=15)
-          if ENV["TRACE_DIRECT_BITS_SLOT40"]
-            puts "      [decode_direct_bits_with_base] START: base=#{base}, num_bits=#{num_bits}"
-            puts "        BEFORE: range=0x#{@range.to_s(16)}, code=0x#{@code.to_s(16)}"
-          end
-          num_bits.times do |i|
+          num_bits.times do |_i|
             result = (result << 1) + 1
-            normalize
+            # Inline normalize
+            if @range < 0x01000000
+              @range <<= 8
+              byte = @stream.getbyte
+              if byte.nil?
+                raise Omnizip::DecompressionError,
+                      "Truncated LZMA stream during range decoder normalization"
+              end
+
+              @code = ((@code << 8) | byte) & 0xFFFFFFFF
+            end
             @range >>= 1
 
-            # Check if bit is 1 before modifying @code
-            # If code >= range, bit is 1; otherwise bit is 0
             bit = @code >= @range ? 1 : 0
 
-            if ENV["TRACE_DIRECT_BITS_SLOT40"] && i < 15
-              puts "        [#{i + 1}/#{num_bits}] bit=#{bit}, result after this step = #{result - (bit.zero? ? 1 : 0)}, range=0x#{@range.to_s(16)}, code=0x#{@code.to_s(16)}"
-            end
-
             if bit == 1
-              # Bit is 1: result stays at (result << 1) + 1
               @code -= @range
             else
-              # Bit is 0: undo the +1, result = (result << 1) + 1 - 1 = result << 1
               result -= 1
             end
           end
-          if ENV["TRACE_DIRECT_BITS_SLOT40"]
-            puts "        [decode_direct_bits_with_base] END: result=#{result}"
-          end
           result
         end
 
         # Reset the range decoder for a new chunk
         #
-        # This matches XZ Utils rc_reset() behavior:
-        # - Reset range to UINT32_MAX (0xFFFFFFFF)
-        # - Reset code to 0
-        # - Set init_bytes_remaining to 5 (lazy initialization)
-        # - Let normalize() read the initialization bytes during actual decoding
-        #
-        # Called during state reset (control >= 0xA0) to reset the range decoder
-        # for the new chunk's compressed data.
-        #
-        # XZ Utils reference: /Users/mulgogi/src/external/xz/src/liblzma/rangecoder/range_decoder.h:181
+        # Resets state only. Call read_init_bytes after the stream is set
+        # to the correct input.
         #
         # @return [void]
         def reset
-          if ENV["LZMA_DEBUG"]
-            stream_pos = begin
-              @stream.pos
-            rescue StandardError
-              "N/A"
-            end
-            warn "      RangeDecoder.reset: BEFORE reset, range=0x#{@range.to_s(16)}, code=0x#{@code.to_s(16)}, stream.pos=#{stream_pos}, init_bytes_remaining=#{@init_bytes_remaining}"
-          end
           @range = 0xFFFFFFFF
           @code = 0
-          # Lazy initialization: set remaining bytes but don't read yet
-          # normalize() will read these bytes during actual decoding
           @init_bytes_remaining = 5
-          if ENV["LZMA_DEBUG"]
-            stream_pos_after = begin
-              @stream.pos
-            rescue StandardError
-              "N/A"
+        end
+
+        # Eagerly read the 5 initialization bytes from the current stream.
+        # Must be called after the stream is set to the correct input.
+        #
+        # @return [void]
+        def read_init_bytes
+          while @init_bytes_remaining.positive?
+            byte = @stream.getbyte
+            if byte.nil?
+              raise Omnizip::DecompressionError,
+                    "Truncated LZMA stream during range decoder initialization"
             end
-            warn "      RangeDecoder.reset: AFTER reset, code=0x#{@code.to_s(16)}, stream.pos=#{stream_pos_after}, init_bytes_remaining=#{@init_bytes_remaining}"
+
+            @code = ((@code << 8) | byte) & 0xFFFFFFFF
+            @init_bytes_remaining -= 1
           end
         end
 
         # Normalize the range when it becomes too small
         #
-        # When range drops below TOP threshold, shift in a new
-        # byte from the input stream and scale up the range by 256.
-        #
-        # XZ Utils pattern (rc_normalize): uses IF, not WHILE!
-        # Each normalize call shifts in at most ONE byte.
-        # See: /Users/mulgogi/src/external/xz/src/liblzma/rangecoder/range_decoder.h:143-149
-        #
-        # XZ Utils lazy initialization (range_decoder.h:146-149):
-        # If init_bytes_remaining > 0, read byte for code initialization
-        # Otherwise, read byte for range normalization
+        # Still needed for decode_freq() and other non-hot paths.
+        # The hot-path methods inline normalize directly.
         #
         # @return [void]
         def normalize
-          # DEBUG: Trace normalize calls
+          # Handle lazy initialization if needed (for non-hot paths)
           if @init_bytes_remaining.positive?
-            stream_pos_before = begin
-              @stream.pos
-            rescue StandardError
-              "N/A"
-            end
-            stream_size = begin
-              @stream.size
-            rescue StandardError
-              "N/A"
-            end
-          end
-
-          # XZ Utils: Handle lazy initialization first
-          # IMPORTANT: Read ALL initialization bytes in a loop, not just one!
-          # XZ Utils rc_normalize reads one byte per call, but decode_bit only calls
-          # normalize once at the start, so we need to loop to read all 5 bytes.
-          while @init_bytes_remaining.positive?
-            byte = @stream.getbyte
-            byte ||= 0
-            code_before = @code
-            @code = ((code_before << 8) | byte) & 0xFFFFFFFF
-            @init_bytes_remaining -= 1
+            while @init_bytes_remaining.positive?
+              byte = @stream.getbyte
+              if byte.nil?
+                raise Omnizip::DecompressionError,
+                      "Truncated LZMA stream during range decoder initialization"
+              end
 
-            if ENV["RANGE_DECODER_TRACE"]
-              puts "\n=== RangeDecoder.normalize (init_bytes_remaining=#{@init_bytes_remaining + 1}) ==="
-              puts "  stream_pos_before=#{stream_pos_before}, stream_size=#{stream_size}"
-              puts "  byte=0x#{byte.to_s(16).upcase}, code_before=0x#{code_before.to_s(16).upcase}"
-              puts "  (code_before << 8) = 0x#{(code_before << 8).to_s(16).upcase}"
-              puts "  ((code_before << 8) | byte) = 0x#{((code_before << 8) | byte).to_s(16).upcase}"
-              puts "  code_after=0x#{@code.to_s(16).upcase}"
+              @code = ((@code << 8) | byte) & 0xFFFFFFFF
+              @init_bytes_remaining -= 1
             end
           end
 
@@ -398,15 +238,6 @@ module Omnizip
             byte = read_byte
             @range <<= 8
             @code = ((@code << 8) | byte) & 0xFFFFFFFF
-            if ENV["RANGE_DECODER_TRACE"]
-              pos = begin
-                @stream.pos
-              rescue StandardError
-                "N/A"
-              end
-              warn "      NORMALIZE: pos=#{pos}, byte=0x#{byte.to_s(16).upcase}, code=0x#{@code.to_s(16).upcase}, range=0x#{@range.to_s(16).upcase}"
-              $stderr.flush
-            end
           end
         end
 
@@ -414,11 +245,6 @@ module Omnizip
 
         # Initialize the decoder by reading the first bytes
         #
-        # XZ Utils rc_read_init (range_decoder.h:160-167):
-        # - Read 5 bytes and construct code value
-        # - code is uint32_t, so it's automatically masked to 32 bits
-        # - In Ruby, we need to explicitly mask to ensure 32-bit value
-        #
         # @return [void]
         def init_decoder
           5.times do
@@ -435,29 +261,11 @@ module Omnizip
         def read_byte
           byte = @stream.getbyte
 
-          # During normal decoding (after initialization), if we run out of input,
-          # this indicates corrupted data - the compressed stream ended prematurely
           if byte.nil? && @initialization_complete && @init_bytes_remaining.zero?
             raise Omnizip::DecompressionError,
                   "LZMA compressed data exhausted prematurely. The file may be corrupted or the uncompressed size field may be incorrect."
           end
 
-          # Only track as data byte if initialization is complete
-          if @initialization_complete && @init_bytes_remaining.zero?
-            pos = begin
-              @stream.pos
-            rescue StandardError
-              "N/A"
-            end
-            if ENV["RANGE_DECODER_TRACE"]
-              warn "      READ_BYTE: pos=#{pos.inspect}, byte=0x#{byte.to_s(16).upcase}"
-              $stderr.flush
-            end
-            if ENV["LZMA_DEBUG"]
-              warn "      READ_BYTE: pos=#{pos.inspect}, byte=0x#{byte.to_s(16).upcase}, @code now=0x#{@code.to_s(16)}"
-            end
-          end
-
           byte || 0
         end
       end

data/lib/omnizip/algorithms/lzma/range_encoder.rb

@@ -61,11 +61,6 @@ module Omnizip
 
           prob = model.probability
 
-          # DEBUG: Trace is_rep bit encoding
-          if ENV["TRACE_IS_REP_BITS"] && bit.zero?
-            puts "  [RangeEncoder.encode_bit] BEFORE: range=#{@range}, low=#{@low}, prob=#{prob}, bit=#{bit}"
-          end
-
           if bit.zero?
             # RC_BIT_0: shrink range to lower portion
             # rc->range = (rc->range >> 11) * prob
@@ -81,10 +76,6 @@ module Omnizip
             @range = (@range - bound) & 0xFFFFFFFF
           end
 
-          if ENV["TRACE_IS_REP_BITS"] && bit.zero?
-            puts "  [RangeEncoder.encode_bit] AFTER: range=#{@range}, low=#{@low}"
-          end
-
           # Update probability model based on the bit value
           # This matches the decoder's update behavior (proper OOP symmetry)
           model.update(bit)

data/lib/omnizip/algorithms/lzma/xz_range_encoder_exact.rb

@@ -128,7 +128,6 @@ module Omnizip
 
         # Queue flush operation (matches XZ Utils rc_flush)
         def flush
-          puts "[FLUSH] Adding 5 RC_FLUSH symbols, @count before=#{@count}" if ENV["DEBUG"]
           5.times do
             raise "Symbol buffer overflow" if @count >= RC_SYMBOLS_MAX
 
@@ -136,7 +135,6 @@ module Omnizip
             @probs[@count] = nil
             @count += 1
           end
-          puts "[FLUSH] @count after=#{@count}" if ENV["DEBUG"]
         end
         alias queue_flush flush
 
@@ -163,8 +161,6 @@ module Omnizip
         def encode(out, out_pos, out_size)
           raise "Symbol buffer overflow" if @count > RC_SYMBOLS_MAX
 
-          puts "[ENCODE] Start: @count=#{@count} @pos=#{@pos} @out_total=#{@out_total}" if ENV["DEBUG"]
-
           skip_increment = false
 
           while @pos < @count
@@ -206,20 +202,11 @@ module Omnizip
               # Prevent further normalizations (XZ Utils behavior)
               @range = 0xFFFFFFFF
 
-              puts "[ENCODE] RC_FLUSH: @pos=#{@pos} @count=#{@count}" if ENV["DEBUG"]
-
-              iteration = 0
               # Flush the last five bytes (see rc_flush)
               begin
-                iteration += 1
-                puts "[ENCODE] RC_FLUSH iteration #{iteration}: @pos=#{@pos}" if ENV["DEBUG"]
                 return true if shift_low(out, out_pos, out_size)
-
-                puts "[ENCODE] After shift_low: @pos=#{@pos}" if ENV["DEBUG"]
               end while (@pos += 1) < @count
 
-              puts "[ENCODE] After RC_FLUSH loop: total #{iteration} iterations" if ENV["DEBUG"]
-
               # Reset the range encoder (matches XZ Utils)
               reset
               # CRITICAL: Skip the @pos increment at loop end because do-while already did it
@@ -233,8 +220,6 @@ module Omnizip
             @pos += 1 unless skip_increment
           end
 
-          puts "[ENCODE] End: @count=#{@count} @pos=#{@pos} @out_total=#{@out_total}" if ENV["DEBUG"]
-
           @count = 0
           @pos = 0
 

data/lib/omnizip/algorithms/lzma/xz_state.rb

@@ -35,7 +35,6 @@ module Omnizip
         # Update state after encoding literal
         # Matches XZ Utils update_literal() macro
         def update_literal
-          old_value = @value
           @value = if @value <= STATE_SHORTREP_LIT_LIT
                      STATE_LIT_LIT
                    elsif @value <= STATE_LIT_SHORTREP
@@ -43,19 +42,12 @@ module Omnizip
                    else
                      @value - 6
                    end
-          if ENV["LZMA_DEBUG"]
-            warn "DEBUG: update_literal - state: #{old_value} → #{@value}"
-          end
         end
 
         # Update state after encoding match
         # Matches XZ Utils update_match() macro
         def update_match
-          old_value = @value
           @value = @value < LIT_STATES ? STATE_LIT_MATCH : STATE_NONLIT_MATCH
-          if ENV["LZMA_DEBUG"]
-            warn "DEBUG: update_match - state: #{old_value} → #{@value}"
-          end
         end
 
         # Update state after encoding long rep match