omnizip 0.3.2 → 0.3.4

data/lib/omnizip/algorithms/zstandard/frame/block.rb

@@ -0,0 +1,128 @@
+# 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_relative "../constants"
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      module Frame
+        # Zstandard block header parser (RFC 8878 Section 3.1.1.2)
+        #
+        # Block_Header structure (3 bytes, little-endian):
+        # - Last_Block: bit 0
+        # - Block_Type: bits 1-2
+        # - Block_Size: bits 3-23
+        class Block
+          include Constants
+
+          # @return [Boolean] True if this is the last block
+          attr_reader :last_block
+
+          # @return [Integer] Block type (0=Raw, 1=RLE, 2=Compressed, 3=Reserved)
+          attr_reader :block_type
+
+          # @return [Integer] Block size in bytes
+          attr_reader :block_size
+
+          # @return [Integer] Block header bytes
+          attr_reader :raw_header
+
+          # Parse block header from input
+          #
+          # @param input [IO] Input stream positioned at block header
+          # @return [Block] Parsed block header
+          def self.parse(input)
+            bytes = input.read(3)
+            # Read 3 bytes as little-endian 24-bit value
+            raw = bytes.nil? ? 0 : (bytes.getbyte(0) | (bytes.getbyte(1) << 8) | (bytes.getbyte(2) << 16))
+            last_block = raw.allbits?(0x01)
+            block_type = (raw >> 1) & 0x03
+            block_size = (raw >> 3) & 0x1FFFFF
+
+            new(last_block, block_type, block_size, raw)
+          end
+
+          # Initialize with parsed values
+          #
+          # @param last_block [Boolean]
+          # @param block_type [Integer]
+          # @param block_size [Integer]
+          # @param raw_header [Integer]
+          def initialize(last_block, block_type, block_size, raw_header)
+            @last_block = last_block
+            @block_type = block_type
+            @block_size = block_size
+            @raw_header = raw_header
+          end
+
+          # Check if this is a raw (uncompressed) block
+          #
+          # @return [Boolean]
+          def raw?
+            @block_type == BLOCK_TYPE_RAW
+          end
+
+          # Check if this is an RLE block
+          #
+          # @return [Boolean]
+          def rle?
+            @block_type == BLOCK_TYPE_RLE
+          end
+
+          # Check if this is a compressed block
+          #
+          # @return [Boolean]
+          def compressed?
+            @block_type == BLOCK_TYPE_COMPRESSED
+          end
+
+          # Check if block type is reserved
+          #
+          # @return [Boolean]
+          def reserved?
+            @block_type == BLOCK_TYPE_RESERVED
+          end
+
+          # Validate block type
+          #
+          # @return [Boolean] True if block type is valid
+          def valid?
+            !reserved?
+          end
+
+          # Get block type name
+          #
+          # @return [Symbol]
+          def type_name
+            case @block_type
+            when BLOCK_TYPE_RAW then :raw
+            when BLOCK_TYPE_RLE then :rle
+            when BLOCK_TYPE_COMPRESSED then :compressed
+            when BLOCK_TYPE_RESERVED then :reserved
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/zstandard/frame/header.rb

@@ -0,0 +1,224 @@
+# 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_relative "../constants"
+
+module Omnizip
+  module Algorithms
+    class Zstandard
+      module Frame
+        # Zstandard frame header parser (RFC 8878 Section 3.1.1.1)
+        #
+        # Frame_Header structure:
+        # - Frame_Header_Descriptor: 1 byte
+        # - Window_Descriptor: 0-1 byte (optional)
+        # - Dictionary_ID: 0-4 bytes (optional)
+        # - Frame_Content_Size: 0-8 bytes (optional)
+        class Header
+          include Constants
+
+          # @return [Integer] Frame content size flag (bits 6-7)
+          attr_reader :content_size_flag
+
+          # @return [Boolean] Single segment flag (bit 5)
+          attr_reader :single_segment
+
+          # @return [Integer] Content checksum flag (bit 2)
+          attr_reader :checksum_flag
+
+          # @return [Integer] Dictionary ID flag (bits 0-1)
+          attr_reader :dictionary_id_flag
+
+          # @return [Integer, nil] Window log value
+          attr_reader :window_log
+
+          # @return [Integer, nil] Dictionary ID
+          attr_reader :dictionary_id
+
+          # @return [Integer, nil] Frame content size
+          attr_reader :content_size
+
+          # @return [Integer] Total header size in bytes
+          attr_reader :header_size
+
+          # Parse frame header from input
+          #
+          # @param input [IO] Input stream positioned at frame header
+          # @return [Header] Parsed header
+          def self.parse(input)
+            descriptor = input.read(1).ord
+
+            header = new(descriptor)
+
+            # Parse optional fields based on descriptor bits
+            if header.window_descriptor?
+              header.send(:parse_window_descriptor, input)
+            end
+
+            if header.dictionary_id?
+              header.send(:parse_dictionary_id, input)
+            end
+
+            if header.content_size?
+              header.send(:parse_content_size, input)
+            end
+
+            header
+          end
+
+          # Initialize with descriptor byte
+          #
+          # @param descriptor [Integer] Frame header descriptor byte
+          def initialize(descriptor)
+            @descriptor = descriptor
+
+            # Extract flags from descriptor byte
+            @content_size_flag = (descriptor >> 6) & 0x03
+            @single_segment = (descriptor >> 5).allbits?(0x01)
+            @checksum_flag = (descriptor >> 2) & 0x01
+            @dictionary_id_flag = descriptor & 0x03
+
+            @window_log = nil
+            @dictionary_id = nil
+            @content_size = nil
+            @header_size = 1
+          end
+
+          # Check if window descriptor is present
+          #
+          # @return [Boolean]
+          def window_descriptor?
+            !@single_segment
+          end
+
+          # Check if dictionary ID is present
+          #
+          # @return [Boolean]
+          def dictionary_id?
+            @dictionary_id_flag != 0
+          end
+
+          # Check if content size is present
+          #
+          # @return [Boolean]
+          def content_size?
+            @content_size_flag != 0 || @single_segment
+          end
+
+          # Check if content checksum is present
+          #
+          # @return [Boolean]
+          def content_checksum?
+            @checksum_flag == 1
+          end
+
+          # Get the size of dictionary ID field
+          #
+          # @return [Integer]
+          def dictionary_id_size
+            case @dictionary_id_flag
+            when 0 then 0
+            when 1 then 1
+            when 2 then 2
+            when 3 then 4
+            end
+          end
+
+          # Get the size of content size field
+          #
+          # @return [Integer]
+          def content_size_size
+            if @single_segment
+              # For single segment, FCS size depends on content_size_flag
+              case @content_size_flag
+              when 0 then 1
+              when 1 then 2
+              when 2 then 4
+              when 3 then 8
+              end
+            else
+              case @content_size_flag
+              when 0 then 0
+              when 1 then 2
+              when 2 then 4
+              when 3 then 8
+              end
+            end
+          end
+
+          # Get window size
+          #
+          # @return [Integer, nil] Window size or nil if not applicable
+          def window_size
+            return nil unless @window_log
+
+            @window_log - 10
+            mantissa = @window_log < 22 ? (@window_log - 10) : (@window_log - 11)
+            (1 << @window_log) + (mantissa << (@window_log - 4))
+          end
+
+          private
+
+          # Parse window descriptor byte
+          def parse_window_descriptor(input)
+            byte = input.read(1).ord
+            exponent = (byte >> 3) & 0x1F
+            byte & 0x07
+            @window_log = 10 + exponent
+            @header_size += 1
+          end
+
+          # Parse dictionary ID (variable size)
+          def parse_dictionary_id(input)
+            size = dictionary_id_size
+            bytes = input.read(size)
+
+            @dictionary_id = case size
+                             when 1 then bytes.ord
+                             when 2 then bytes.unpack1("v")
+                             when 4 then bytes.unpack1("V")
+                             end
+
+            @header_size += size
+          end
+
+          # Parse content size (variable size)
+          def parse_content_size(input)
+            size = content_size_size
+            bytes = input.read(size)
+
+            @content_size = case size
+                            when 1 then bytes.ord
+                            when 2 then bytes.unpack1("v")
+                            when 4 then bytes.unpack1("V")
+                            when 8
+                              low, high = bytes.unpack("VV")
+                              low + (high << 32)
+                            end
+
+            @header_size += size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/algorithms/zstandard/fse/bitstream.rb

@@ -0,0 +1,186 @@
+# 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 Zstandard
+      module FSE
+        # FSE bitstream reader (RFC 8878 Section 4.1)
+        #
+        # Reads FSE-encoded bitstreams which are read in reverse order
+        # (from end to beginning) according to RFC 8878.
+        #
+        # The bitstream is consumed from the end toward the beginning,
+        # with bits read from LSB to MSB within each byte.
+        class BitStream
+          # @return [String] The compressed data
+          attr_reader :data
+
+          # @return [Integer] Current bit position (from end)
+          attr_reader :bit_position
+
+          # Initialize bitstream with data
+          #
+          # @param data [String] The compressed bitstream data
+          def initialize(data)
+            @data = data.dup.force_encoding(Encoding::BINARY)
+            @bit_position = data.bytesize * 8
+          end
+
+          # Read bits from the stream (in reverse order)
+          #
+          # Bits are read from LSB to MSB, starting from the end of the stream.
+          #
+          # @param count [Integer] Number of bits to read
+          # @return [Integer] The read bits
+          def read_bits(count)
+            return 0 if count.zero?
+
+            result = 0
+            count.times do |i|
+              bit = read_single_bit
+              result |= (bit << i)
+            end
+            result
+          end
+
+          # Peek at bits without consuming them
+          #
+          # @param count [Integer] Number of bits to peek
+          # @return [Integer] The peeked bits
+          def peek_bits(count)
+            saved_position = @bit_position
+            result = read_bits(count)
+            @bit_position = saved_position
+            result
+          end
+
+          # Check if bitstream is exhausted
+          #
+          # @return [Boolean]
+          def exhausted?
+            @bit_position <= 0
+          end
+
+          # Get remaining bits
+          #
+          # @return [Integer]
+          def remaining_bits
+            @bit_position
+          end
+
+          # Align to byte boundary (skip remaining bits in current byte)
+          def align_to_byte
+            @bit_position = ((@bit_position + 7) / 8) * 8
+          end
+
+          private
+
+          # Read a single bit from the stream
+          #
+          # @return [Integer] 0 or 1
+          def read_single_bit
+            return 0 if @bit_position <= 0
+
+            @bit_position -= 1
+            byte_index = @bit_position / 8
+            bit_index = @bit_position % 8
+
+            return 0 if byte_index.negative? || byte_index >= @data.bytesize
+
+            byte = @data.getbyte(byte_index)
+            (byte >> bit_index) & 1
+          end
+        end
+
+        # Forward bitstream reader (for Huffman decoding)
+        #
+        # Reads bits in normal forward order from a starting position.
+        class ForwardBitStream
+          # @return [String] The compressed data
+          attr_reader :data
+
+          # @return [Integer] Current bit position
+          attr_reader :bit_position
+
+          # Initialize bitstream with data
+          #
+          # @param data [String] The compressed bitstream data
+          # @param start_byte [Integer] Starting byte position
+          def initialize(data, start_byte = 0)
+            @data = data.dup.force_encoding(Encoding::BINARY)
+            @bit_position = start_byte * 8
+          end
+
+          # Read bits from the stream (in forward order)
+          #
+          # Bits are read from MSB to LSB within each byte.
+          #
+          # @param count [Integer] Number of bits to read
+          # @return [Integer] The read bits
+          def read_bits(count)
+            return 0 if count.zero?
+
+            result = 0
+            count.times do
+              result = (result << 1) | read_single_bit
+            end
+            result
+          end
+
+          # Check if bitstream is exhausted
+          #
+          # @return [Boolean]
+          def exhausted?
+            @bit_position >= @data.bytesize * 8
+          end
+
+          # Get current byte position
+          #
+          # @return [Integer]
+          def byte_position
+            @bit_position / 8
+          end
+
+          private
+
+          # Read a single bit from the stream
+          #
+          # @return [Integer] 0 or 1
+          def read_single_bit
+            return 0 if exhausted?
+
+            byte_index = @bit_position / 8
+            bit_index = 7 - (@bit_position % 8) # MSB first
+
+            @bit_position += 1
+
+            return 0 if byte_index >= @data.bytesize
+
+            byte = @data.getbyte(byte_index)
+            (byte >> bit_index) & 1
+          end
+        end
+      end
+    end
+  end
+end