cabriolet 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d2875b9afed58332c6e9823f3f383a60d802bac8514cb2015fdbd6a7f1559dc
-  data.tar.gz: 6979ce57ad3d47867bed19330d70b5db483bc33ac8920ee2986faa35828d6cbc
+  metadata.gz: cb8a4d045d1bc49ab6448b9d1890524386e743d27249ad5dd5c5e630140e8a20
+  data.tar.gz: c63202e8fe947a0d14b3f4ffaca42feae67dc04e392ce3f9eac00d90ab0293b1
 SHA512:
-  metadata.gz: edd7b1345bee36e75fb5796a3840f087a9dfa51e41c599fa767938e8d64ab0abc985e563b9fb246fc86fc4798eb3f98539f774023eaf613f50a1c9e4a2a6d518
-  data.tar.gz: c5cfc76ae8dc5239efa9e90d0956d2518eab56c669d4b7e4087debc4955f509cc97440296c53084152cb30059b25044b6231cd9a84ee94e85f446a20f3306e08
+  metadata.gz: 6f6111054718818537222c48d986ef6a6112c89b9ea019ba748176402142316e7c2eef54979904e3bc7078f8d3b809193afcfe4acf971e9498d5cf4e7c4020dd
+  data.tar.gz: 8c0f0b712a10a5751f267cb67afe3c7d369ef6f06df0f961a2e92168f288c667fd97503e4fbfb95531898a8fec4303202e29b093814618c0065a7fbba8e3701f

data/lib/cabriolet/algorithm_factory.rb

@@ -91,7 +91,7 @@ module Cabriolet
     #   compressor = factory.create(3, :compressor,
     #                               io, input, output, 8192)
     def create(type, category, io_system, input, output, buffer_size,
-               **kwargs)
+               **)
       validate_category!(category)
 
       normalized_type = normalize_type(type)
@@ -103,7 +103,7 @@ module Cabriolet
       end
 
       algorithm_info[:class].new(io_system, input, output, buffer_size,
-                                 **kwargs)
+                                 **)
     end
 
     # Check if an algorithm is registered

data/lib/cabriolet/base_compressor.rb

@@ -57,8 +57,8 @@ module Cabriolet
     # @param options [Hash] Format-specific options
     # @return [FileEntry] Added entry
     # @raise [ArgumentError] if file doesn't exist
-    def add_file(source_path, archive_path = nil, **options)
-      @file_manager.add_file(source_path, archive_path, **options)
+    def add_file(source_path, archive_path = nil, **)
+      @file_manager.add_file(source_path, archive_path, **)
     end
 
     # Add file from memory to archive
@@ -67,8 +67,8 @@ module Cabriolet
     # @param archive_path [String] Path in archive
     # @param options [Hash] Format-specific options
     # @return [FileEntry] Added entry
-    def add_data(data, archive_path, **options)
-      @file_manager.add_data(data, archive_path, **options)
+    def add_data(data, archive_path, **)
+      @file_manager.add_data(data, archive_path, **)
     end
 
     # Generate archive (Template Method)
@@ -165,7 +165,7 @@ module Cabriolet
     # @option options [Integer] :window_bits Window size in bits
     # @option options [Integer] :mode Algorithm mode
     # @return [String] Compressed data
-    def compress_data(data, algorithm:, **options)
+    def compress_data(data, algorithm:, **)
       input = System::MemoryHandle.new(data)
       output = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
@@ -176,7 +176,7 @@ module Cabriolet
         input,
         output,
         data.bytesize,
-        **options,
+        **,
       )
 
       compressor.compress

data/lib/cabriolet/binary/bitstream.rb

@@ -4,7 +4,7 @@ module Cabriolet
   module Binary
     # Bitstream provides bit-level I/O operations for reading compressed data
     class Bitstream
-      attr_reader :io_system, :handle, :buffer_size, :bit_order
+      attr_reader :io_system, :handle, :buffer_size, :bit_order, :bits_left
 
       # Initialize a new bitstream
       #
@@ -29,6 +29,9 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
         # For MSB mode, we need to know the bit width of the buffer
         # Ruby integers are arbitrary precision, so we use 32 bits as standard
         @bitbuf_width = 32
+
+        # Cache ENV lookups once at initialization
+        @debug_bitstream = ENV.fetch("DEBUG_BITSTREAM", nil)
       end
 
       # Read specified number of bits from the stream
@@ -83,7 +86,7 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
           byte = 0 if byte.nil?
 
           # DEBUG
-          if ENV["DEBUG_BITSTREAM"]
+          if @debug_bitstream
             warn "DEBUG LSB read_byte: buffer_pos=#{@buffer_pos} byte=#{byte} (#{byte.to_s(2).rjust(
               8, '0'
             )}) bits_left=#{@bits_left}"
@@ -101,7 +104,7 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
         @bits_left -= num_bits
 
         # DEBUG
-        warn "DEBUG LSB read_bits(#{num_bits}): result=#{result} buffer=#{@bit_buffer.to_s(16)} bits_left=#{@bits_left}" if ENV["DEBUG_BITSTREAM"]
+        warn "DEBUG LSB read_bits(#{num_bits}): result=#{result} buffer=#{@bit_buffer.to_s(16)} bits_left=#{@bits_left}" if @debug_bitstream
 
         result
       end
@@ -116,7 +119,7 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
           word = read_msb_word
 
           # DEBUG
-          warn "DEBUG MSB read_bytes: word=0x#{word.to_s(16)} bits_left=#{@bits_left}" if ENV["DEBUG_BITSTREAM"]
+          warn "DEBUG MSB read_bytes: word=0x#{word.to_s(16)} bits_left=#{@bits_left}" if @debug_bitstream
 
           # INJECT_BITS (MSB): inject at the left side
           @bit_buffer |= (word << (@bitbuf_width - 16 - @bits_left))
@@ -131,7 +134,7 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
         @bits_left -= num_bits
 
         # DEBUG
-        warn "DEBUG MSB read_bits(#{num_bits}) result=#{result} (0x#{result.to_s(16)}) buffer=0x#{@bit_buffer.to_s(16)} bits_left=#{@bits_left}" if ENV["DEBUG_BITSTREAM"]
+        warn "DEBUG MSB read_bits(#{num_bits}) result=#{result} (0x#{result.to_s(16)}) buffer=0x#{@bit_buffer.to_s(16)} bits_left=#{@bits_left}" if @debug_bitstream
 
         result
       end
@@ -172,15 +175,62 @@ buffer_size = Cabriolet.default_buffer_size, bit_order: :lsb, salvage: false)
         byte
       end
 
+      # Ensure at least num_bits are available in the bit buffer.
+      # Reads from input if needed. Used for alignment operations.
+      #
+      # @param num_bits [Integer] Minimum number of bits required
+      # @return [void]
+      def ensure_bits(num_bits)
+        if @bit_order == :msb
+          while @bits_left < num_bits
+            word = read_msb_word
+            @bit_buffer |= (word << (@bitbuf_width - 16 - @bits_left))
+            @bits_left += 16
+          end
+        else
+          while @bits_left < num_bits
+            byte = read_byte
+            byte = 0 if byte.nil?
+            @bit_buffer |= (byte << @bits_left)
+            @bits_left += 8
+          end
+        end
+      end
+
       # Align to the next byte boundary
       #
       # @return [void]
       def byte_align
         discard_bits = @bits_left % 8
-        @bit_buffer >>= discard_bits
+        if @bit_order == :msb
+          # MSB mode: valid bits are at the left (high) end, shift left to discard
+          @bit_buffer = (@bit_buffer << discard_bits) & ((1 << @bitbuf_width) - 1)
+        else
+          @bit_buffer >>= discard_bits
+        end
         @bits_left -= discard_bits
       end
 
+      # Flush the bit buffer entirely (discard all remaining bits).
+      # Per libmspack lzxd.c: used when transitioning to raw byte reading
+      # for uncompressed blocks. Sets bits_left=0 and bit_buffer=0.
+      #
+      # @return [void]
+      def flush_bit_buffer
+        @bit_buffer = 0
+        @bits_left = 0
+      end
+
+      # Read a raw byte directly from the input, bypassing the bit buffer.
+      # Per libmspack lzxd.c: uncompressed block headers and data are read
+      # directly from the input pointer (i_ptr), not through the bitstream.
+      # Call flush_bit_buffer first to discard any residual bits.
+      #
+      # @return [Integer] Byte value (0 on EOF)
+      def read_raw_byte
+        read_byte || 0
+      end
+
       # Peek at bits without consuming them
       #
       # @param num_bits [Integer] Number of bits to peek at

data/lib/cabriolet/cab/decompressor.rb

@@ -36,9 +36,9 @@ module Cabriolet
       # @param output_path [String] Where to write the file
       # @param options [Hash] Extraction options
       # @return [Integer] Number of bytes extracted
-      def extract_file(file, output_path, **options)
+      def extract_file(file, output_path, **)
         extractor = Extractor.new(@io_system, self)
-        extractor.extract_file(file, output_path, **options)
+        extractor.extract_file(file, output_path, **)
       end
 
       # Extract all files from the cabinet
@@ -47,9 +47,9 @@ module Cabriolet
       # @param output_dir [String] Directory to extract to
       # @param options [Hash] Extraction options
       # @return [Integer] Number of files extracted
-      def extract_all(cabinet, output_dir, **options)
+      def extract_all(cabinet, output_dir, **)
         extractor = Extractor.new(@io_system, self)
-        extractor.extract_all(cabinet, output_dir, **options)
+        extractor.extract_all(cabinet, output_dir, **)
       end
 
       # Create appropriate decompressor for a folder
@@ -157,8 +157,11 @@ module Cabriolet
               offset = cab_offset + 4
             end
           else
-            # No cabinet found in this chunk, move to next
-            offset += length
+            # No cabinet found in this chunk, move to next.
+            # Overlap by 20 bytes so MSCF signatures spanning chunk
+            # boundaries are not missed (state machine reads 20 bytes).
+            overlap = length > 20 ? 20 : 0
+            offset += [length - overlap, 1].max
           end
         end
 
@@ -452,7 +455,7 @@ file_length)
                                                         cablen_u32, caboff, file_length)
 
             # Not valid, restart search after "MSCF"
-            return nil
+            state = 0
           end
         end
 

data/lib/cabriolet/cab/extractor.rb

@@ -22,6 +22,9 @@ module Cabriolet
         @current_decomp = nil
         @current_input = nil
         @current_offset = 0
+
+        # Cache ENV lookups once at initialization
+        @debug_block = ENV.fetch("DEBUG_BLOCK", nil)
       end
 
       # Extract a single file from the cabinet
@@ -57,7 +60,8 @@ module Cabriolet
         begin
           write_file_data(output_fh, filelen)
         rescue DecompressionError
-          handle_extraction_error(output_fh, output_path, file.filename, salvage, filelen)
+          handle_extraction_error(output_fh, output_path, file.filename,
+                                  salvage, filelen)
         ensure
           output_fh.close
         end
@@ -69,6 +73,7 @@ module Cabriolet
       def reset_state
         @current_input&.close
         @current_input = nil
+        @current_decomp&.free # Free decompressor buffers to prevent memory leaks
         @current_decomp = nil
         @current_folder = nil
         @current_offset = 0
@@ -133,6 +138,9 @@ module Cabriolet
         warn "Salvage: #{failed_count} file(s) skipped due to extraction errors" if failed_count.positive?
 
         count
+      ensure
+        # Clean up resources to prevent memory leaks
+        reset_state
       end
 
       private
@@ -185,7 +193,7 @@ module Cabriolet
       # @param salvage [Boolean] Salvage mode flag
       # @param file_offset [Integer] File offset for reset condition check
       def setup_decompressor_for_folder(folder, salvage, file_offset)
-        if ENV["DEBUG_BLOCK"]
+        if @debug_block
           warn "DEBUG extract_file: Checking reset condition"
           warn "  @current_folder == folder: #{@current_folder == folder}"
           warn "  @current_offset (#{@current_offset}) > file_offset (#{file_offset})"
@@ -193,7 +201,7 @@ module Cabriolet
         end
 
         if @current_folder != folder || @current_offset > file_offset || !@current_decomp
-          if ENV["DEBUG_BLOCK"]
+          if @debug_block
             warn "DEBUG extract_file: RESETTING state (creating new BlockReader)"
           end
 
@@ -211,7 +219,20 @@ module Cabriolet
           # Create decompressor ONCE and reuse it
           @current_decomp = @decompressor.create_decompressor(folder,
                                                               @current_input, nil)
-        elsif ENV["DEBUG_BLOCK"]
+
+          # Per libmspack cabd.c: set output_length from the folder's total
+          # uncompressed size (max file.offset + file.length across all files
+          # in the folder). This allows the LZX decompressor to reduce the
+          # last frame's size so it doesn't read past the end of the stream.
+          if @current_decomp.respond_to?(:set_output_length)
+            cab = folder.data&.cabinet
+            if cab&.files
+              folder_files = cab.files.select { |f| f.folder == folder }
+              max_end = folder_files.map { |f| f.offset + f.length }.max
+              @current_decomp.set_output_length(max_end) if max_end&.positive?
+            end
+          end
+        elsif @debug_block
           warn "DEBUG extract_file: NOT resetting (reusing existing BlockReader)"
         end
       end
@@ -228,7 +249,6 @@ module Cabriolet
         null_output = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
         @current_decomp.instance_variable_set(:@output, null_output)
-        @current_decomp.set_output_length(skip_bytes) if @current_decomp.respond_to?(:set_output_length)
 
         begin
           @current_decomp.decompress(skip_bytes)
@@ -248,8 +268,12 @@ module Cabriolet
       # @param output_fh [System::FileHandle] Output file handle
       # @param filelen [Integer] Number of bytes to write
       def write_file_data(output_fh, filelen)
+        unless @current_decomp
+          raise DecompressionError,
+                "Decompressor not available (state was reset)"
+        end
+
         @current_decomp.instance_variable_set(:@output, output_fh)
-        @current_decomp.set_output_length(filelen) if @current_decomp.respond_to?(:set_output_length)
         @current_decomp.decompress(filelen)
         @current_offset += filelen
       end
@@ -261,7 +285,8 @@ module Cabriolet
       # @param filename [String] Filename for error messages
       # @param salvage [Boolean] Salvage mode flag
       # @raise [DecompressionError] If not in salvage mode
-      def handle_extraction_error(output_fh, output_path, filename, salvage, _filelen)
+      def handle_extraction_error(output_fh, output_path, filename, salvage,
+_filelen)
         output_fh.close
         if salvage
           ::File.write(output_path, "", mode: "wb")
@@ -311,6 +336,9 @@ module Cabriolet
           @buffer_pos = 0
           @cab_handle = nil
 
+          # Cache ENV lookups once at initialization
+          @debug_block = ENV.fetch("DEBUG_BLOCK", nil)
+
           # Open first cabinet and seek to data offset
           open_current_cabinet
         end
@@ -318,7 +346,7 @@ module Cabriolet
         def read(bytes)
           # Early return if we've already exhausted all blocks and buffer
           if @current_block >= @num_blocks && @buffer_pos >= @buffer.bytesize
-            if ENV["DEBUG_BLOCK"]
+            if @debug_block
               warn "DEBUG BlockReader.read(#{bytes}): Already exhausted, returning empty"
             end
             return +""
@@ -326,14 +354,14 @@ module Cabriolet
 
           result = +""
 
-          if ENV["DEBUG_BLOCK"]
+          if @debug_block
             warn "DEBUG BlockReader.read(#{bytes}): buffer_size=#{@buffer.bytesize} buffer_pos=#{@buffer_pos} block=#{@current_block}/#{@num_blocks}"
           end
 
           while result.bytesize < bytes
             # Read more data if buffer is empty
             if (@buffer_pos >= @buffer.bytesize) && !read_next_block
-              if ENV["DEBUG_BLOCK"]
+              if @debug_block
                 warn "DEBUG BlockReader.read: EXHAUSTED at result.bytesize=#{result.bytesize} (wanted #{bytes})"
               end
               break
@@ -347,7 +375,7 @@ module Cabriolet
             @buffer_pos += to_copy
           end
 
-          if ENV["DEBUG_BLOCK"]
+          if @debug_block
             warn "DEBUG BlockReader.read: returning #{result.bytesize} bytes"
           end
 
@@ -371,12 +399,12 @@ module Cabriolet
         private
 
         def read_next_block
-          if ENV["DEBUG_BLOCK"]
+          if @debug_block
             warn "DEBUG read_next_block: current_block=#{@current_block} num_blocks=#{@num_blocks}"
           end
 
           if @current_block >= @num_blocks
-            if ENV["DEBUG_BLOCK"]
+            if @debug_block
               warn "DEBUG read_next_block: EXHAUSTED (current_block >= num_blocks)"
             end
             return false
@@ -387,19 +415,19 @@ module Cabriolet
 
           loop do
             # Read CFDATA header
-            if ENV["DEBUG_BLOCK"]
+            if @debug_block
               handle_pos = @cab_handle.tell
               warn "DEBUG read_next_block: About to read CFDATA header at position #{handle_pos}"
             end
 
             header_data = @cab_handle.read(Constants::CFDATA_SIZE)
 
-            if ENV["DEBUG_BLOCK"]
+            if @debug_block
               warn "DEBUG read_next_block: Read #{header_data.bytesize} bytes (expected #{Constants::CFDATA_SIZE})"
             end
 
             if header_data.bytesize != Constants::CFDATA_SIZE
-              if ENV["DEBUG_BLOCK"]
+              if @debug_block
                 warn "DEBUG read_next_block: FAILED - header read returned #{header_data.bytesize} bytes"
               end
               return false
@@ -427,18 +455,18 @@ module Cabriolet
             end
 
             # Read compressed data
-            if ENV["DEBUG_BLOCK"]
+            if @debug_block
               warn "DEBUG read_next_block: About to read #{cfdata.compressed_size} bytes of compressed data"
             end
 
             compressed_data = @cab_handle.read(cfdata.compressed_size)
 
-            if ENV["DEBUG_BLOCK"]
+            if @debug_block
               warn "DEBUG read_next_block: Read #{compressed_data.bytesize} bytes of compressed data (expected #{cfdata.compressed_size})"
             end
 
             if compressed_data.bytesize != cfdata.compressed_size
-              if ENV["DEBUG_BLOCK"]
+              if @debug_block
                 warn "DEBUG read_next_block: FAILED - compressed data read returned #{compressed_data.bytesize} bytes"
               end
               return false
@@ -482,7 +510,7 @@ module Cabriolet
         end
 
         def open_current_cabinet
-          if ENV["DEBUG_BLOCK"]
+          if @debug_block
             warn "DEBUG open_current_cabinet: filename=#{@current_data.cabinet.filename} offset=#{@current_data.offset}"
           end
 
@@ -490,7 +518,7 @@ module Cabriolet
           @cab_handle = @io_system.open(@current_data.cabinet.filename, Constants::MODE_READ)
           @cab_handle.seek(@current_data.offset, Constants::SEEK_START)
 
-          if ENV["DEBUG_BLOCK"]
+          if @debug_block
             actual_pos = @cab_handle.tell
             warn "DEBUG open_current_cabinet: seeked to position #{actual_pos} (expected #{@current_data.offset})"
           end

data/lib/cabriolet/cab/parser.rb

@@ -23,6 +23,9 @@ module Cabriolet
         cabinet = parse_handle(handle, filename)
         @io_system.close(handle)
         cabinet
+      rescue StandardError
+        @io_system.close(handle) if handle
+        raise
       end
 
       # Parse a CAB from an already-open handle

data/lib/cabriolet/checksum.rb

@@ -28,14 +28,17 @@ module Cabriolet
         ul = 0
         offset = bytes.size - remainder
 
+        # Match libmspack's cabd_checksum remainder handling:
+        # The C fall-through switch processes bytes in decreasing shift
+        # order (first remaining byte gets the highest shift).
         case remainder
         when 3
-          ul |= bytes[offset + 2] << 16
+          ul |= bytes[offset] << 16
           ul |= bytes[offset + 1] << 8
-          ul |= bytes[offset]
+          ul |= bytes[offset + 2]
         when 2
-          ul |= bytes[offset + 1] << 8
-          ul |= bytes[offset]
+          ul |= bytes[offset] << 8
+          ul |= bytes[offset + 1]
         when 1
           ul |= bytes[offset]
         end

data/lib/cabriolet/cli.rb

@@ -422,11 +422,11 @@ module Cabriolet
     # @param command [Symbol] Command to execute
     # @param file [String] File path
     # @param args [Array] Additional arguments
-    def run_dispatcher(command, file, *args, **options)
+    def run_dispatcher(command, file, *, **options)
       setup_verbose(options[:verbose])
 
       dispatcher = Commands::CommandDispatcher.new(**options)
-      dispatcher.dispatch(command, file, *args, **options)
+      dispatcher.dispatch(command, file, *, **options)
     end
 
     # Run command with explicit format override
@@ -435,12 +435,12 @@ module Cabriolet
     # @param format [Symbol] Format to force
     # @param file [String] File path
     # @param args [Array] Additional arguments
-    def run_with_format(command, format, file, *args, **options)
+    def run_with_format(command, format, file, *, **options)
       setup_verbose(options[:verbose])
       options[:format] = format.to_s
 
       dispatcher = Commands::CommandDispatcher.new(**options)
-      dispatcher.dispatch(command, file, *args, **options)
+      dispatcher.dispatch(command, file, *, **options)
     end
 
     # Detect format from output file extension

data/lib/cabriolet/compressors/lzx.rb

@@ -89,7 +89,7 @@ module Cabriolet
                                                  buffer_size, bit_order: :msb)
 
         # Initialize sliding window for LZ77
-        @window = "\0" * @window_size
+        @window = ("\0" * @window_size).b
         @window_pos = 0
 
         # Initialize R0, R1, R2 (LRU offset registers)
@@ -153,6 +153,11 @@ module Cabriolet
 
       # Compress a single frame (32KB)
       #
+      # Per libmspack lzxd.c: uncompressed blocks write R0/R1/R2 and data
+      # as raw bytes directly to the stream, NOT through the MSB bitstream.
+      # The bitstream is flushed (padded to 16-bit boundary) after the
+      # block header, then raw bytes follow.
+      #
       # @param data [String] Frame data to compress
       # @return [void]
       def compress_frame(data)
@@ -163,12 +168,12 @@ module Cabriolet
         # Write UNCOMPRESSED block header
         write_block_header(BLOCKTYPE_UNCOMPRESSED, block_length)
 
-        # Write offset registers (R0, R1, R2)
+        # Write offset registers (R0, R1, R2) as raw bytes
         write_offset_registers
 
-        # Write raw uncompressed data
+        # Write raw uncompressed data (bypassing MSB bitstream)
         data.each_byte do |byte|
-          @bitstream.write_bits(byte, 8)
+          @bitstream.write_raw_byte(byte)
         end
       end
 
@@ -571,14 +576,17 @@ module Cabriolet
 
       # Write offset registers (R0, R1, R2) for uncompressed blocks
       #
+      # Per libmspack lzxd.c: R0/R1/R2 are written as raw bytes directly
+      # to the stream (not through the MSB bitstream) to avoid byte-swapping.
+      #
       # @return [void]
       def write_offset_registers
-        # Write R0, R1, R2 as 32-bit little-endian values (12 bytes total)
+        # Write R0, R1, R2 as 32-bit little-endian values (12 raw bytes total)
         [@r0, @r1, @r2].each do |offset|
-          @bitstream.write_bits(offset & 0xFF, 8)
-          @bitstream.write_bits((offset >> 8) & 0xFF, 8)
-          @bitstream.write_bits((offset >> 16) & 0xFF, 8)
-          @bitstream.write_bits((offset >> 24) & 0xFF, 8)
+          @bitstream.write_raw_byte(offset & 0xFF)
+          @bitstream.write_raw_byte((offset >> 8) & 0xFF)
+          @bitstream.write_raw_byte((offset >> 16) & 0xFF)
+          @bitstream.write_raw_byte((offset >> 24) & 0xFF)
         end
       end
 

data/lib/cabriolet/compressors/mszip.rb

@@ -66,7 +66,7 @@ module Cabriolet
         @fixed_codes = Huffman::Encoder.build_fixed_codes
 
         # Initialize sliding window for LZ77
-        @window = "\0" * WINDOW_SIZE
+        @window = ("\0" * WINDOW_SIZE).b
         @window_pos = 0
       end
 

data/lib/cabriolet/decompressors/lzss.rb

@@ -31,11 +31,12 @@ module Cabriolet
                      mode = MODE_EXPAND)
         super(io_system, input, output, buffer_size)
         @mode = mode
-        @window = Array.new(WINDOW_SIZE, WINDOW_FILL)
+        @window = (WINDOW_FILL.chr * WINDOW_SIZE).b
         @window_pos = initialize_window_position
         @input_buffer = ""
         @input_pos = 0
         @invert = mode == MODE_MSHELP ? 0xFF : 0x00
+        @output_buffer = String.new(encoding: Encoding::BINARY, capacity: 4096)
       end
 
       # Decompress LZSS data
@@ -69,8 +70,8 @@ module Cabriolet
               literal = read_input_byte
               break if literal.nil?
 
-              @window[@window_pos] = literal
-              write_output_byte(literal)
+              @window.setbyte(@window_pos, literal)
+              buffer_output_byte(literal)
               bytes_written += 1
 
               @window_pos = (@window_pos + 1) & (WINDOW_SIZE - 1)
@@ -91,9 +92,9 @@ module Cabriolet
                 # Check if we've reached the limit mid-match
                 break if enforce_limit && bytes_written >= bytes
 
-                byte = @window[match_pos]
-                @window[@window_pos] = byte
-                write_output_byte(byte)
+                byte = @window.getbyte(match_pos)
+                @window.setbyte(@window_pos, byte)
+                buffer_output_byte(byte)
                 bytes_written += 1
 
                 @window_pos = (@window_pos + 1) & (WINDOW_SIZE - 1)
@@ -103,6 +104,7 @@ module Cabriolet
           end
         end
 
+        flush_output_buffer
         bytes_written
       end
 
@@ -131,17 +133,23 @@ module Cabriolet
         byte
       end
 
-      # Write a single byte to the output
+      # Buffer an output byte and flush when buffer is full
       #
-      # @param byte [Integer] Byte to write
+      # @param byte [Integer] Byte to buffer
       # @return [void]
-      # @raise [Errors::DecompressionError] if write fails
-      def write_output_byte(byte)
-        data = [byte].pack("C")
-        written = @io_system.write(@output, data)
-        return if written == 1
+      def buffer_output_byte(byte)
+        @output_buffer << byte.chr
+        flush_output_buffer if @output_buffer.bytesize >= 4096
+      end
+
+      # Flush the output buffer to the output stream
+      #
+      # @return [void]
+      def flush_output_buffer
+        return if @output_buffer.empty?
 
-        raise Errors::DecompressionError, "Failed to write output byte"
+        @io_system.write(@output, @output_buffer)
+        @output_buffer.clear
       end
     end
   end