pure_jpeg 0.3.3 → 0.4.1

data/lib/pure_jpeg/huffman/decoder.rb

@@ -4,6 +4,16 @@ module PureJPEG
   module Huffman
     class DecodeTable
       def initialize(bits, values)
+        unless bits.length == 16 && bits.all? { |n| n.is_a?(Integer) && n.between?(0, 255) } &&
+               values.length.between?(1, 256) && bits.sum == values.length
+          raise DecodeError, "Invalid JPEG Huffman table lengths"
+        end
+        available = 1
+        bits.each do |count|
+          available = available * 2 - count
+          # JPEG reserves the all-ones code for entropy padding.
+          raise DecodeError, "Oversubscribed JPEG Huffman table" if available <= 0
+        end
         @min_code = Array.new(17, 0)
         @max_code = Array.new(17, -1)
         @val_ptr = Array.new(17, 0)
@@ -25,13 +35,15 @@ module PureJPEG
       end
 
       # Decode one Huffman symbol from the bit reader.
-      def decode(reader)
+      def decode_symbol(reader)
         code = 0
-        1.upto(16) do |len|
+        len = 1
+        while len <= 16
           code = (code << 1) | reader.read_bit
           if @max_code[len] >= 0 && code <= @max_code[len]
             return @values[@val_ptr[len] + code - @min_code[len]]
           end
+          len += 1
         end
         raise PureJPEG::DecodeError, "Invalid Huffman code"
       end

data/lib/pure_jpeg/huffman/encoder.rb

@@ -6,14 +6,7 @@ module PureJPEG
       # Return the Huffman category (bit length) for a value.
       # Avoids Array allocation compared to the combined category_and_bits.
       def self.category(value)
-        return 0 if value == 0
-        v = value.abs
-        cat = 0
-        while v > 0
-          cat += 1
-          v >>= 1
-        end
-        cat
+        value.abs.bit_length
       end
 
       # Return the extra bits to encode for a value with the given category.
@@ -50,6 +43,7 @@ module PureJPEG
         end
 
         yield 0x00, 0 if last_nonzero < 63
+        nil
       end
 
       def self.each_ac_symbol(zigzag)
@@ -85,12 +79,12 @@ module PureJPEG
       end
 
       def encode_ac(zigzag, writer)
-        self.class.each_ac_item(zigzag) do |symbol, value|
+        PureJPEG::Huffman::Encoder.each_ac_item(zigzag) do |symbol, value|
           code, length = @ac_table[symbol]
           writer.write_bits(code, length)
           next if symbol == 0x00 || symbol == 0xF0
 
-          cat = self.class.category(value)
+          cat = symbol & 0x0F
           writer.write_bits(self.class.value_bits(value, cat), cat)
         end
       end

data/lib/pure_jpeg/jfif_reader.rb

@@ -3,19 +3,24 @@
 module PureJPEG
   class JFIFReader
     attr_reader :width, :height, :components, :quant_tables, :huffman_tables,
-                :restart_interval, :progressive, :scans, :icc_profile
+                :restart_interval, :progressive, :scans, :icc_profile,
+                :precision, :adobe_transform, :component_quant_tables
 
     Component = Struct.new(:id, :h_sampling, :v_sampling, :qt_id)
     ScanComponent = Struct.new(:id, :dc_table_id, :ac_table_id)
-    Scan = Struct.new(:components, :spectral_start, :spectral_end, :successive_high, :successive_low, :data, :huffman_tables)
+    Scan = Struct.new(:components, :spectral_start, :spectral_end, :successive_high, :successive_low, :data, :huffman_tables) do
+      attr_accessor :restart_interval
+    end
 
-    def initialize(data, stop_after_frame: false)
+    def initialize(data, stop_after_frame: false, metadata_only: false)
       @data = data.b
       @stop_after_frame = stop_after_frame
+      @metadata_only = metadata_only
       @pos = 0
       @quant_tables = {}
       @huffman_tables = {}
       @components = []
+      @component_quant_tables = {}
       @restart_interval = 0
       @progressive = false
       @scans = []
@@ -38,16 +43,20 @@ module PureJPEG
       expect_marker(0xD8) # SOI
 
       loop do
+        # Header-only input is useful for metadata queries, even without SOS.
+        return if @metadata_only && @width && @pos == @data.bytesize
         marker = read_marker
         case marker
         when 0xE2 # APP2 (may contain ICC profile)
           parse_app2
-        when 0xE0, 0xE1, 0xE3..0xEF # APP0, APP1, APP3-APP15
+        when 0xEE # Adobe APP14
+          parse_app14
+        when 0xE0, 0xE1, 0xE3..0xED, 0xEF # Other application markers
           skip_segment
         when 0xDB # DQT
-          parse_dqt
+          @metadata_only ? skip_segment : parse_dqt
         when 0xC4 # DHT
-          parse_dht
+          @metadata_only ? skip_segment : parse_dht
         when 0xC0 # SOF0 (baseline)
           parse_sof0
           return if @stop_after_frame
@@ -56,17 +65,30 @@ module PureJPEG
           @progressive = true
           return if @stop_after_frame
         when 0xDA # SOS
+          return if @metadata_only
           scan = parse_sos
           scan.data = extract_scan_data
           scan.huffman_tables = @huffman_tables.dup
+          scan.restart_interval = @restart_interval
+          # A component keeps the quantizer selected by its first scan, even
+          # if another scan later redefines that table ID for other components.
+          scan.components.each do |sc|
+            comp = @components.find { |c| c.id == sc.id }
+            if comp && !@component_quant_tables.key?(comp.id)
+              @component_quant_tables[comp.id] = @quant_tables[comp.qt_id]
+            end
+          end
           @scans << scan
-          return unless @progressive
         when 0xFE # COM (comment)
           skip_segment
         when 0xDD # DRI (restart interval)
           parse_dri
         when 0xD9 # EOI
           return
+        when 0xC1, 0xC3, 0xC5..0xCB, 0xCD..0xCF
+          raise DecodeError, "Unsupported JPEG frame marker: 0x#{marker.to_s(16)}"
+        when 0xD0..0xD8, 0x00, 0x01
+          raise DecodeError, "Unexpected JPEG marker: 0x#{marker.to_s(16)}"
         else
           skip_segment
         end
@@ -100,13 +122,24 @@ module PureJPEG
 
     ICC_PROFILE_SIG = "ICC_PROFILE\0".b
 
+    def parse_app14
+      end_pos = read_segment_end
+      if end_pos - @pos >= 12 && @data[@pos, 5] == "Adobe"
+        @adobe_transform = @data.getbyte(@pos + 11)
+      end
+      @pos = end_pos
+    end
+
     def parse_app2
       end_pos = read_segment_end
 
       if (end_pos - @pos) >= 14 && @data[@pos, 12] == ICC_PROFILE_SIG
         @pos += 12
         seq_no = read_byte
-        _total = read_byte
+        total = read_byte
+        @icc_invalid = true if total == 0 || seq_no == 0 || seq_no > total ||
+                               (@icc_total && @icc_total != total) || @icc_chunks.key?(seq_no)
+        @icc_total = total
         @icc_chunks[seq_no] = @data[@pos, end_pos - @pos]
       end
 
@@ -115,6 +148,7 @@ module PureJPEG
 
     def assemble_icc_profile
       return if @icc_chunks.empty?
+      return if @icc_invalid || @icc_chunks.length != @icc_total
 
       @icc_profile = @icc_chunks.sort_by(&:first).map(&:last).join.b
     end
@@ -130,6 +164,9 @@ module PureJPEG
         info = read_byte
         precision = (info >> 4) & 0x0F  # 0 = 8-bit, 1 = 16-bit
         table_id = info & 0x0F
+        unless precision <= 1 && table_id <= 3
+          raise DecodeError, "Invalid JPEG quantization table definition"
+        end
         bytes_per_value = precision == 0 ? 1 : 2
         ensure_remaining_in_segment!(end_pos, 64 * bytes_per_value, "DQT")
 
@@ -137,6 +174,7 @@ module PureJPEG
         64.times do |i|
           zigzag_table[i] = precision == 0 ? read_byte : read_u16
         end
+        raise DecodeError, "Zero JPEG quantization value" if zigzag_table.include?(0)
         # DQT stores values in zigzag order; convert to raster order
         table = Array.new(64)
         64.times { |i| table[Zigzag::ORDER[i]] = zigzag_table[i] }
@@ -152,20 +190,27 @@ module PureJPEG
         info = read_byte
         table_class = (info >> 4) & 0x0F  # 0 = DC, 1 = AC
         table_id = info & 0x0F
+        unless table_class <= 1 && table_id <= 3
+          raise DecodeError, "Invalid JPEG Huffman table definition"
+        end
 
         bits = Array.new(16) { read_byte }
         total = bits.sum
         ensure_remaining_in_segment!(end_pos, total, "DHT")
         values = Array.new(total) { read_byte }
+        if values.any? { |value| table_class == 0 ? value > 11 : (value & 15) > 10 }
+          raise DecodeError, "Invalid JPEG Huffman symbol"
+        end
 
         @huffman_tables[[table_class, table_id]] = { bits: bits, values: values }
       end
     end
 
     def parse_sof0
+      raise DecodeError, "Multiple JPEG frame headers are unsupported" if @width
       end_pos = read_segment_end
       ensure_remaining_in_segment!(end_pos, 6, "SOF")
-      read_byte # precision (always 8 for baseline)
+      @precision = read_byte
       @height = read_u16
       @width = read_u16
       num_components = read_byte
@@ -179,6 +224,13 @@ module PureJPEG
         qt_id = read_byte
         Component.new(id, h, v, qt_id)
       end
+      raise DecodeError, "JPEG frame has no components" if @components.empty?
+      if @components.map(&:id).uniq.length != @components.length
+        raise DecodeError, "Duplicate JPEG component id"
+      end
+      unless @components.all? { |c| c.h_sampling.between?(1, 4) && c.v_sampling.between?(1, 4) }
+        raise DecodeError, "Invalid JPEG sampling factors"
+      end
       @pos = end_pos
     end
 
@@ -234,19 +286,23 @@ module PureJPEG
     def extract_scan_data
       start = @pos
       len = @data.bytesize
-      # Scan forward looking for a marker that isn't a stuffing byte or restart
-      while @pos < len - 1
+      # Preserve the first FF of a marker's fill run for read_marker. Stuffed
+      # bytes and restarts belong to the entropy stream, segment markers do not.
+      while @pos < len
         found = @data.index("\xFF".b, @pos)
-        break unless found && found < len - 1
-        @pos = found
-        next_byte = @data.getbyte(@pos + 1)
-        # 0x00 is byte stuffing, 0xD0-0xD7 are restart markers, 0xFF is padding — all part of scan data
-        if next_byte != 0x00 && !(next_byte >= 0xD0 && next_byte <= 0xD7) && next_byte != 0xFF
-          break
+        raise DecodeError, "Unexpected end of JPEG scan" unless found
+        marker_pos = found + 1
+        marker_pos += 1 while marker_pos < len && @data.getbyte(marker_pos) == 0xFF
+        raise DecodeError, "Unexpected end of JPEG scan" if marker_pos == len
+        code = @data.getbyte(marker_pos)
+        if code == 0x00 || code.between?(0xD0, 0xD7)
+          @pos = marker_pos + 1
+        else
+          @pos = found
+          return @data[start...found]
         end
-        @pos += 2
       end
-      @data[start...@pos]
+      raise DecodeError, "Unexpected end of JPEG scan"
     end
   end
 end

data/lib/pure_jpeg/quantization.rb

@@ -58,5 +58,33 @@ module PureJPEG
       64.times { |i| out[i] = block[i] * table[i] }
       out
     end
+
+    # Quantize raster-order coefficients directly into zigzag order.
+    def self.quantize_zigzag!(block, table, out)
+      order = Zigzag::ORDER
+      i = 0
+      while i < 64
+        j = order[i]
+        v = block[j]; t = table[j]
+        out[i] = if v >= 0
+                   (v + (t >> 1)) / t
+                 else
+                   -((-v + (t >> 1)) / t)
+                 end
+        i += 1
+      end
+      out
+    end
+
+    # Dequantize zigzag coefficients directly into raster order. The offset
+    # allows progressive decoding to read from its full coefficient buffer.
+    def self.dequantize_zigzag!(block, table, out, offset = 0)
+      order = Zigzag::ORDER
+      64.times do |i|
+        j = order[i]
+        out[j] = block[offset + i] * table[j]
+      end
+      out
+    end
   end
 end

data/lib/pure_jpeg/source/raw_source.rb

@@ -27,15 +27,16 @@ module PureJPEG
       def initialize(width, height, &block)
         @width = width
         @height = height
-        @pixels = Array.new(width * height) { Pixel.new(0, 0, 0) }
-
         if block
+          @pixels = Array.new(width * height)
           height.times do |y|
             width.times do |x|
               r, g, b = block.call(x, y)
               @pixels[y * width + x] = Pixel.new(r, g, b)
             end
           end
+        else
+          @pixels = Array.new(width * height) { Pixel.new(0, 0, 0) }
         end
       end
 

data/lib/pure_jpeg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PureJPEG
-  VERSION = "0.3.3"
+  VERSION = "0.4.1"
 end

data/lib/pure_jpeg.rb

@@ -21,10 +21,9 @@ require_relative "pure_jpeg/image"
 require_relative "pure_jpeg/encoder"
 require_relative "pure_jpeg/decoder"
 
-  # Pure Ruby JPEG encoder and decoder with no native dependencies.
-  #
-  # Supports baseline DCT (SOF0) with 8-bit precision, grayscale and YCbCr
-  # color (4:2:0 chroma subsampling), and standard Huffman tables (Annex K).
+# Pure Ruby JPEG encoder and decoder with no native dependencies.
+# Encodes baseline DCT (SOF0), and decodes baseline and progressive (SOF2)
+# 8-bit grayscale and YCbCr JPEGs.
 module PureJPEG
   # Raised when decoding invalid or unsupported JPEG data.
   class DecodeError < StandardError; end
@@ -70,15 +69,15 @@ module PureJPEG
   # Read JPEG dimensions and basic frame metadata without decoding scan data.
   #
   # @param path_or_data [String] a file path or raw JPEG bytes
-  # @return [Info] image metadata parsed from the frame header
+  # @return [Info] frame metadata and complete ICC profile from headers before SOS
   def self.info(path_or_data)
-    data = if path_or_data.is_a?(String) && !path_or_data.start_with?("\xFF\xD8".b) && File.exist?(path_or_data)
+    data = if path_or_data.is_a?(String) && !path_or_data.b.include?("\0") && !path_or_data.b.start_with?("\xFF\xD8".b) && File.exist?(path_or_data)
              File.binread(path_or_data)
            else
              path_or_data.b
            end
 
-    jfif = JFIFReader.new(data, stop_after_frame: true)
+    jfif = JFIFReader.new(data, metadata_only: true)
     raise DecodeError, "JPEG frame header not found" unless jfif.width && jfif.height
 
     Info.new(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pure_jpeg
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.1
 platform: ruby
 authors:
 - Peter Cooper
@@ -37,7 +37,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: A pure Ruby baseline JPEG encoder and decoder with no native dependencies.
+description: A pure Ruby baseline JPEG encoder and baseline/progressive JPEG decoder
+  with no native dependencies.
 email:
 - git@peterc.org
 executables: []
@@ -45,7 +46,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CREATIVE.md
 - LICENSE
+- LICENSE-IJG
 - README.md
 - lib/pure_jpeg.rb
 - lib/pure_jpeg/bit_reader.rb
@@ -69,6 +72,7 @@ files:
 homepage: https://github.com/peterc/pure_jpeg
 licenses:
 - MIT
+- IJG
 metadata:
   source_code_uri: https://github.com/peterc/pure_jpeg
   changelog_uri: https://github.com/peterc/pure_jpeg/blob/main/CHANGELOG.md