fastimage 2.3.0 → 2.4.0

data/lib/fastimage/fastimage_parsing/exif.rb

@@ -0,0 +1,76 @@
+module FastImageParsing
+  class Exif # :nodoc:
+    attr_reader :width, :height, :orientation
+  
+    def initialize(stream)
+      @stream = stream
+      @width, @height, @orientation = nil
+      parse_exif
+    end
+  
+    def rotated?
+      @orientation >= 5
+    end
+  
+    private
+  
+    def get_exif_byte_order
+      byte_order = @stream.read(2)
+      case byte_order
+      when 'II'
+        @short, @long = 'v', 'V'
+      when 'MM'
+        @short, @long = 'n', 'N'
+      else
+        raise FastImage::CannotParseImage
+      end
+    end
+  
+    def parse_exif_ifd
+      tag_count = @stream.read(2).unpack(@short)[0]
+      tag_count.downto(1) do
+        type = @stream.read(2).unpack(@short)[0]
+        data_type = @stream.read(2).unpack(@short)[0]
+        @stream.read(4)
+
+        if data_type == 4
+          data = @stream.read(4).unpack(@long)[0]
+        else
+          data = @stream.read(2).unpack(@short)[0]
+          @stream.read(2)
+        end
+
+        case type
+        when 0x0100 # image width
+          @width = data
+        when 0x0101 # image height
+          @height = data
+        when 0x0112 # orientation
+          @orientation = data
+        end
+        if @width && @height && @orientation
+          return # no need to parse more
+        end
+      end
+    end
+  
+    def parse_exif
+      @start_byte = @stream.pos
+  
+      get_exif_byte_order
+  
+      @stream.read(2) # 42
+  
+      offset = @stream.read(4).unpack(@long)[0]
+      if @stream.respond_to?(:skip)
+        @stream.skip(offset - 8)
+      else
+        @stream.read(offset - 8)
+      end
+  
+      parse_exif_ifd
+  
+      @orientation ||= 1
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/fiber_stream.rb

@@ -0,0 +1,58 @@
+module FastImageParsing
+  class FiberStream # :nodoc:
+    include StreamUtil
+    attr_reader :pos
+  
+    # read_fiber should return nil if it no longer has anything to return when resumed
+    # so the result of the whole Fiber block should be set to be nil in case yield is no
+    # longer called
+    def initialize(read_fiber)
+      @read_fiber = read_fiber
+      @pos = 0
+      @strpos = 0
+      @str = ''
+    end
+  
+    # Peeking beyond the end of the input will raise
+    def peek(n)
+      while @strpos + n > @str.size
+        unused_str = @str[@strpos..-1]
+  
+        new_string = @read_fiber.resume
+        raise FastImage::CannotParseImage if !new_string
+        # we are dealing with bytes here, so force the encoding
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
+  
+        @str = unused_str + new_string
+        @strpos = 0
+      end
+  
+      @str[@strpos, n]
+    end
+  
+    def read(n)
+      result = peek(n)
+      @strpos += n
+      @pos += n
+      result
+    end
+  
+    def skip(n)
+      discarded = 0
+      fetched = @str[@strpos..-1].size
+      while n > fetched
+        discarded += @str[@strpos..-1].size
+        new_string = @read_fiber.resume
+        raise FastImage::CannotParseImage if !new_string
+  
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
+  
+        fetched += new_string.size
+        @str = new_string
+        @strpos = 0
+      end
+      @strpos = @strpos + n - discarded
+      @pos += n
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/gif.rb

@@ -0,0 +1,63 @@
+module FastImageParsing
+  class Gif < ImageBase # :nodoc:  
+    def dimensions
+      @stream.read(11)[6..10].unpack('SS')
+    end
+  
+    # Checks for multiple frames
+    def animated?
+      frames = 0
+  
+      # "GIF" + version (3) + width (2) + height (2)
+      @stream.skip(10)
+  
+      # fields (1) + bg color (1) + pixel ratio (1)
+      fields = @stream.read(3).unpack("CCC")[0]
+      if fields & 0x80 != 0 # Global Color Table
+        # 2 * (depth + 1) colors, each occupying 3 bytes (RGB)
+        @stream.skip(3 * 2 ** ((fields & 0x7) + 1))
+      end
+  
+      loop do
+        block_type = @stream.read(1).unpack("C")[0]
+  
+        if block_type == 0x21 # Graphic Control Extension
+          # extension type (1) + size (1)
+          size = @stream.read(2).unpack("CC")[1]
+          @stream.skip(size)
+          skip_sub_blocks
+        elsif block_type == 0x2C # Image Descriptor
+          frames += 1
+          return true if frames > 1
+  
+          # left position (2) + top position (2) + width (2) + height (2) + fields (1)
+          fields = @stream.read(9).unpack("SSSSC")[4]
+          if fields & 0x80 != 0 # Local Color Table
+            # 2 * (depth + 1) colors, each occupying 3 bytes (RGB)
+            @stream.skip(3 * 2 ** ((fields & 0x7) + 1))
+          end
+  
+          @stream.skip(1) # LZW min code size (1)
+          skip_sub_blocks
+        else
+          break # unrecognized block
+        end
+      end
+  
+      false
+    end
+  
+    private
+  
+    def skip_sub_blocks
+      loop do
+        size = @stream.read(1).unpack("C")[0]
+        if size == 0
+          break
+        else
+          @stream.skip(size)
+        end
+      end
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/heic.rb

@@ -0,0 +1,8 @@
+module FastImageParsing
+  class Heic < ImageBase # :nodoc:
+    def dimensions
+      bmff = IsoBmff.new(@stream)
+      [bmff.width, bmff.height]
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/ico.rb

@@ -0,0 +1,9 @@
+module FastImageParsing
+  class Ico < ImageBase
+    def dimensions
+      icons = @stream.read(6)[4..5].unpack('v').first
+      sizes = icons.times.map { @stream.read(16).unpack('C2').map { |x| x == 0 ? 256 : x } }.sort_by { |w,h| w * h }
+      sizes.last
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/image_base.rb

@@ -0,0 +1,17 @@
+module FastImageParsing
+  class ImageBase # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+  
+    # Implement in subclasses
+    def dimensions
+      raise NotImplementedError
+    end
+    
+    # Implement in subclasses if appropriate
+    def animated?
+      nil
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/iso_bmff.rb

@@ -0,0 +1,176 @@
+module FastImageParsing
+  # HEIC/AVIF are a special case of the general ISO_BMFF format, in which all data is encapsulated in typed boxes,
+  # with a mandatory ftyp box that is used to indicate particular file types. Is composed of nested "boxes". Each
+  # box has a header composed of
+  # - Size (32 bit integer)
+  # - Box type (4 chars)
+  # - Extended size: only if size === 1, the type field is followed by 64 bit integer of extended size
+  # - Payload: Type-dependent
+  class IsoBmff # :nodoc:
+    attr_reader :width, :height
+  
+    def initialize(stream)
+      @stream = stream
+      @width, @height = nil
+      parse_isobmff
+    end
+    
+    def parse_isobmff
+      @rotation = 0
+      @max_size = nil
+      @primary_box = nil
+      @ipma_boxes = []
+      @ispe_boxes = []
+      @final_size = nil
+
+      catch :finish do
+        read_boxes!
+      end
+
+      if [90, 270].include?(@rotation)
+        @final_size.reverse!
+      end
+      
+      @width, @height = @final_size
+    end
+
+    private
+
+    # Format specs: https://www.loc.gov/preservation/digital/formats/fdd/fdd000525.shtml
+
+    # If you need to inspect a heic/heif file, use
+    # https://gpac.github.io/mp4box.js/test/filereader.html
+    def read_boxes!(max_read_bytes = nil)
+      end_pos = max_read_bytes.nil? ? nil : @stream.pos + max_read_bytes
+      index = 0
+
+      loop do
+        return if end_pos && @stream.pos >= end_pos
+
+        box_type, box_size = read_box_header!
+
+        case box_type
+        when "meta"
+          handle_meta_box(box_size)
+        when "pitm"
+          handle_pitm_box(box_size)
+        when "ipma"
+          handle_ipma_box(box_size)
+        when "hdlr"
+          handle_hdlr_box(box_size)
+        when "iprp", "ipco"
+          read_boxes!(box_size)
+        when "irot"
+          handle_irot_box
+        when "ispe"
+          handle_ispe_box(box_size, index)
+        when "mdat"
+          @stream.skip(box_size)
+        when "jxlc"
+          handle_jxlc_box(box_size)
+        else
+          @stream.skip(box_size)
+        end
+
+        index += 1
+      end
+    end
+
+    def handle_irot_box
+      @rotation = (read_uint8! & 0x3) * 90
+    end
+
+    def handle_ispe_box(box_size, index)
+      throw :finish if box_size < 12
+
+      data = @stream.read(box_size)
+      width, height = data[4...12].unpack("N2")
+      @ispe_boxes << { index: index, size: [width, height] }
+    end
+
+    def handle_hdlr_box(box_size)
+      throw :finish if box_size < 12
+
+      data = @stream.read(box_size)
+      throw :finish if data[8...12] != "pict"
+    end
+
+    def handle_ipma_box(box_size)
+      @stream.read(3)
+      flags3 = read_uint8!
+      entries_count = read_uint32!
+
+      entries_count.times do
+        id = read_uint16!
+        essen_count = read_uint8!
+
+        essen_count.times do
+          property_index = read_uint8! & 0x7F
+
+          if flags3 & 1 == 1
+            property_index = (property_index << 7) + read_uint8!
+          end
+
+          @ipma_boxes << { id: id, property_index: property_index - 1 }
+        end
+      end
+    end
+
+    def handle_pitm_box(box_size)
+      data = @stream.read(box_size)
+      @primary_box = data[4...6].unpack("S>")[0]
+    end
+
+    def handle_meta_box(box_size)
+      throw :finish if box_size < 4
+
+      @stream.read(4)
+      read_boxes!(box_size - 4)
+
+      throw :finish if !@primary_box
+
+      primary_indices = @ipma_boxes
+                        .select { |box| box[:id] == @primary_box }
+                        .map { |box| box[:property_index] }
+
+      ispe_box = @ispe_boxes.find do |box|
+        primary_indices.include?(box[:index])
+      end
+
+      if ispe_box
+        @final_size = ispe_box[:size]
+      end
+
+      throw :finish
+    end
+
+    def handle_jxlc_box(box_size)
+      jxlc = Jxlc.new(@stream)
+      @final_size = [jxlc.width, jxlc.height]
+      throw :finish
+    end
+
+    def read_box_header!
+      size = read_uint32!
+      type = @stream.read(4)
+      size = read_uint64! - 8 if size == 1
+      [type, size - 8]
+    end
+
+    def read_uint8!
+      @stream.read(1).unpack("C")[0]
+    end
+
+    def read_uint16!
+      @stream.read(2).unpack("S>")[0]
+    end
+
+    def read_uint32!
+      @stream.read(4).unpack("N")[0]
+    end
+
+    def read_uint64!
+      @stream.read(8).unpack("Q>")[0]
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/jpeg.rb

@@ -0,0 +1,52 @@
+module FastImageParsing
+  class IOStream < SimpleDelegator # :nodoc:
+    include StreamUtil
+  end
+  
+  class Jpeg < ImageBase # :nodoc:
+    def dimensions
+      exif = nil
+      state = nil
+      loop do
+        state = case state
+        when nil
+          @stream.skip(2)
+          :started
+        when :started
+          @stream.read_byte == 0xFF ? :sof : :started
+        when :sof
+          case @stream.read_byte
+          when 0xe1 # APP1
+            skip_chars = @stream.read_int - 2
+            data = @stream.read(skip_chars)
+            io = StringIO.new(data)
+            if io.read(4) == "Exif"
+              io.read(2)
+              new_exif = Exif.new(IOStream.new(io)) rescue nil
+              exif ||= new_exif # only use the first APP1 segment
+            end
+            :started
+          when 0xe0..0xef
+            :skipframe
+          when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF
+            :readsize
+          when 0xFF
+            :sof
+          else
+            :skipframe
+          end
+        when :skipframe
+          skip_chars = @stream.read_int - 2
+          @stream.skip(skip_chars)
+          :started
+        when :readsize
+          @stream.skip(3)
+          height = @stream.read_int
+          width = @stream.read_int
+          width, height = height, width if exif && exif.rotated?
+          return [width, height, exif ? exif.orientation : 1]
+        end
+      end
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/jxl.rb

@@ -0,0 +1,13 @@
+module FastImageParsing
+  class Jxl < ImageBase # :nodoc:
+    def dimensions
+      if @stream.peek(2) == "\xFF\x0A".b
+        jxlc = Jxlc.new(@stream)
+        [jxlc.width, jxlc.height]
+      else
+        bmff = IsoBmff.new(@stream)
+        [bmff.width, bmff.height]
+      end
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/jxlc.rb

@@ -0,0 +1,75 @@
+module FastImageParsing
+  class Jxlc # :nodoc:
+    attr_reader :width, :height
+
+    LENGTHS = [9, 13, 18, 30]
+    MULTIPLIERS = [1, 1.2, Rational(4, 3), 1.5, Rational(16, 9), 1.25, 2]
+  
+    def initialize(stream)
+      @stream = stream
+      @width, @height´ = nil
+      @bit_counter = 0
+      parse_jxlc
+    end
+    
+    def parse_jxlc
+      @words = @stream.read(6)[2..5].unpack('vv')
+
+      # small mode allows for values <= 256 that are divisible by 8
+      small = get_bits(1)
+      if small == 1
+        y = (get_bits(5) + 1) * 8
+        x = x_from_ratio(y)
+        if !x
+          x = (get_bits(5) + 1) * 8
+        end
+        @width, @height = x, y
+        return
+      end
+
+      len = LENGTHS[get_bits(2)]
+      y = get_bits(len) + 1
+      x = x_from_ratio(y)
+      if !x
+        len = LENGTHS[get_bits(2)]
+        x = get_bits(len) + 1
+      end
+      @width, @height = x, y
+    end
+
+    def get_bits(size)
+      if @words.size < (@bit_counter + size) / 16 + 1
+        @words += @stream.read(4).unpack('vv')
+      end
+
+      dest_pos = 0
+      dest = 0
+      size.times do
+        word = @bit_counter / 16
+        source_pos = @bit_counter % 16
+        dest |= ((@words[word] & (1 << source_pos)) > 0 ? 1 : 0) << dest_pos
+        dest_pos += 1
+        @bit_counter += 1
+      end
+      dest
+    end
+
+    def x_from_ratio(y)
+      ratio = get_bits(3)
+      if ratio == 0
+        return nil
+      else
+        return (y * MULTIPLIERS[ratio - 1]).to_i
+      end
+    end
+  end
+
+  def parse_size_for_jxl
+    if @stream.peek(2) == "\xFF\x0A".b
+      JXL.new(@stream).read_size_header
+    else
+      bmff = IsoBmff.new(@stream)
+      bmff.width_and_height
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/png.rb

@@ -0,0 +1,26 @@
+module FastImageParsing
+  class Png < ImageBase # :nodoc:
+    def dimensions
+      @stream.read(25)[16..24].unpack('NN')
+    end
+    
+    def animated?
+      # Signature (8) + IHDR chunk (4 + 4 + 13 + 4)
+      @stream.read(33)
+
+      loop do
+        length = @stream.read(4).unpack("L>")[0]
+        type = @stream.read(4)
+
+        case type
+        when "acTL"
+          return true
+        when "IDAT"
+          return false
+        end
+
+        @stream.skip(length + 4)
+      end
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/psd.rb

@@ -0,0 +1,7 @@
+module FastImageParsing
+  class Psd < ImageBase # :nodoc:
+    def dimensions
+      @stream.read(26).unpack("x14NN").reverse
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/stream_util.rb

@@ -0,0 +1,19 @@
+module FastImageParsing
+  module StreamUtil # :nodoc:
+    def read_byte
+      read(1)[0].ord
+    end
+  
+    def read_int
+      read(2).unpack('n')[0]
+    end
+  
+    def read_string_int
+      value = []
+      while read(1) =~ /(\d)/
+        value << $1
+      end
+      value.join.to_i
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/svg.rb

@@ -0,0 +1,69 @@
+module FastImageParsing
+  class Svg < ImageBase # :nodoc:
+    def dimensions
+      @width, @height, @ratio, @viewbox_width, @viewbox_height = nil
+
+      parse_svg
+      
+      if @width && @height
+        [@width, @height]
+      elsif @width && @ratio
+        [@width, @width / @ratio]
+      elsif @height && @ratio
+        [@height * @ratio, @height]
+      elsif @viewbox_width && @viewbox_height
+        [@viewbox_width, @viewbox_height]
+      else
+        nil
+      end
+    end
+  
+    private
+  
+    def parse_svg
+      attr_name = []
+      state = nil
+  
+      while (char = @stream.read(1)) && state != :stop do
+        case char
+        when "="
+          if attr_name.join =~ /width/i
+            @stream.read(1)
+            @width = @stream.read_string_int
+            return if @height
+          elsif attr_name.join =~ /height/i
+            @stream.read(1)
+            @height = @stream.read_string_int
+            return if @width
+          elsif attr_name.join =~ /viewbox/i
+            values = attr_value.split(/\s/)
+            if values[2].to_f > 0 && values[3].to_f > 0
+              @ratio = values[2].to_f / values[3].to_f
+              @viewbox_width = values[2].to_i
+              @viewbox_height = values[3].to_i
+            end
+          end
+        when /\w/
+          attr_name << char
+        when "<"
+          attr_name = [char]
+        when ">"
+          state = :stop if state == :started
+        else
+          state = :started if attr_name.join == "<svg"
+          attr_name.clear
+        end
+      end
+    end
+  
+    def attr_value
+      @stream.read(1)
+  
+      value = []
+      while @stream.read(1) =~ /([^"])/
+        value << $1
+      end
+      value.join
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/tiff.rb

@@ -0,0 +1,16 @@
+module FastImageParsing
+  class Tiff < ImageBase # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+  
+    def dimensions
+      exif = Exif.new(@stream)
+      if exif.rotated?
+        [exif.height, exif.width, exif.orientation]
+      else
+        [exif.width, exif.height, exif.orientation]
+      end
+    end
+  end
+end