fastimage 2.3.1 → 2.4.0

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

data/lib/fastimage/fastimage_parsing/type_parser.rb

@@ -0,0 +1,69 @@
+module FastImageParsing
+  class TypeParser
+    def initialize(stream)
+      @stream = stream
+    end
+    
+    # type will use peek to get enough bytes to determing the type of the image
+    def type
+      parsed_type = case @stream.peek(2)
+      when "BM"
+        :bmp
+      when "GI"
+        :gif
+      when 0xff.chr + 0xd8.chr
+        :jpeg
+      when 0x89.chr + "P"
+        :png
+      when "II", "MM"
+        case @stream.peek(11)[8..10]
+        when "APC", "CR\002"
+          nil  # do not recognise CRW or CR2 as tiff
+        else
+          :tiff
+        end
+      when '8B'
+        :psd
+      when "\xFF\x0A".b
+        :jxl
+      when "\0\0"
+        case @stream.peek(3).bytes.to_a.last
+        when 0
+          # http://www.ftyps.com/what.html
+          case @stream.peek(12)[4..-1]
+          when "ftypavif"
+            :avif
+          when "ftypavis"
+            :avif
+          when "ftypheic"
+            :heic
+          when "ftypmif1"
+            :heif
+          else
+            if @stream.peek(7)[4..-1] == 'JXL'
+              :jxl
+            end
+          end
+        # ico has either a 1 (for ico format) or 2 (for cursor) at offset 3
+        when 1 then :ico
+        when 2 then :cur
+        end
+      when "RI"
+        :webp if @stream.peek(12)[8..11] == "WEBP"
+      when "<s"
+        :svg if @stream.peek(4) == "<svg"
+      when /\s\s|\s<|<[?!]/, 0xef.chr + 0xbb.chr
+        # Peek 10 more chars each time, and if end of file is reached just raise
+        # unknown. We assume the <svg tag cannot be within 10 chars of the end of
+        # the file, and is within the first 1000 chars.
+        begin
+          :svg if (1..100).detect {|n| @stream.peek(10 * n).include?("<svg")}
+        rescue FiberError, FastImage::CannotParseImage
+          nil
+        end
+      end
+
+      parsed_type or raise FastImage::UnknownImageType
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/webp.rb

@@ -0,0 +1,60 @@
+module FastImageParsing
+  class Webp < ImageBase # :nodoc:
+    def dimensions
+      vp8 = @stream.read(16)[12..15]
+      _len = @stream.read(4).unpack("V")
+      case vp8
+      when "VP8 "
+        parse_size_vp8
+      when "VP8L"
+        parse_size_vp8l
+      when "VP8X"
+        parse_size_vp8x
+      else
+        nil
+      end
+    end
+    
+    def animated?
+      vp8 = @stream.read(16)[12..15]
+      _len = @stream.read(4).unpack("V")
+      case vp8
+      when "VP8 "
+        false
+      when "VP8L"
+        false
+      when "VP8X"
+        flags = @stream.read(4).unpack("C")[0]
+        flags & 2 > 0
+      else
+        nil
+      end
+    end
+    
+    private
+  
+    def parse_size_vp8
+      w, h = @stream.read(10).unpack("@6vv")
+      [w & 0x3fff, h & 0x3fff]
+    end
+
+    def parse_size_vp8l
+      @stream.skip(1) # 0x2f
+      b1, b2, b3, b4 = @stream.read(4).bytes.to_a
+      [1 + (((b2 & 0x3f) << 8) | b1), 1 + (((b4 & 0xF) << 10) | (b3 << 2) | ((b2 & 0xC0) >> 6))]
+    end
+
+    def parse_size_vp8x
+      flags = @stream.read(4).unpack("C")[0]
+      b1, b2, b3, b4, b5, b6 = @stream.read(6).unpack("CCCCCC")
+      width, height = 1 + b1 + (b2 << 8) + (b3 << 16), 1 + b4 + (b5 << 8) + (b6 << 16)
+
+      if flags & 8 > 0 # exif
+        # parse exif for orientation
+        # TODO: find or create test images for this
+      end
+
+      [width, height]
+    end
+  end
+end

data/lib/fastimage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class FastImage
-  VERSION = '2.3.1'
+  VERSION = '2.4.0'
 end