fastimage 2.2.0 → 2.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53c0966ef5216c189e2950b1ad36c106777175f0d4dca9851abd34472fd9cb61
-  data.tar.gz: 29f5a6bc03623e184166e7f9c5e8c4379011b301904d4c690037d5b7b0ba0b33
+  metadata.gz: d7667683a4bbc8ac16d583fb3ed7c93e6a58a25c19bf8df909ab7dae8d4ef782
+  data.tar.gz: 0baf5dcf6af104d0edd38baf65b7b35c972e6fc4271363d52855071e22b97a82
 SHA512:
-  metadata.gz: 28e8ec4debe6c2c477da19cafb1ad41e5de4d809136bd86621ae128372c32c1259abea833856f73dfcfe8ef3444bc5e1a148f91b52ee02d3292235c4d95fc542
-  data.tar.gz: ba8b4c6bb42146387b1a8af718fbbaf74a9a94532ee5adce082ff676095dad5d5e0eb613f1ec41d7729709847195fa81c4614f2d9d510d6c7def67f8970f168e
+  metadata.gz: 9261157ade925ba5be4761028b4d70a698f1cc4d54e4ef0fcb7f4b23b6120ae6f9c42516b0dc17f915c423d168a4ef66c805a686ea20e3ca311556ce3e930593
+  data.tar.gz: 2d319a0aa6c4e7c7a3d951b3025d6215ac999bc2efe5d054720dac9c063cb3e2939e35e30660cf360bfae5f88285b91bb8029ec594c64ca1eb9e3e4144fa6b4c

data/README.textile

@@ -132,7 +132,7 @@ h2. Tests
 
 You'll need to @gem install fakeweb@ and possibly also  @gem install test-unit@ to be able to run the tests.
 
-bc.. $ ruby test.rb
+bc.. $ ruby test/test.rb
 Run options:
 
 # Running tests:
@@ -156,6 +156,7 @@ h2. FastImage in other languages
 * "Node.js by ShogunPanda":https://github.com/ShogunPanda/fastimage
 * "Objective C by kylehickinson":https://github.com/kylehickinson/FastImage
 * "Android by qstumn":https://github.com/qstumn/FastImageSize
+* "Flutter by ky1vstar":https://github.com/ky1vstar/fastimage.dart
 
 h2. Licence
 

data/lib/fastimage/version.rb

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

data/lib/fastimage.rb

@@ -61,6 +61,7 @@ require 'pathname'
 require 'zlib'
 require 'base64'
 require 'uri'
+require_relative 'fastimage/version'
 
 # see http://stackoverflow.com/questions/5208851/i/41048816#41048816
 if RUBY_VERSION < "2.2"
@@ -89,6 +90,8 @@ class FastImage
 
   LocalFileChunkSize = 256 unless const_defined?(:LocalFileChunkSize)
 
+  SUPPORTED_IMAGE_TYPES = [:bmp, :gif, :jpeg, :png, :tiff, :psd, :heic, :heif, :webp, :svg, :ico, :cur].freeze
+
   # Returns an array containing the width and height of the image.
   # It will return nil if the image could not be fetched, or if the image type was not recognised.
   #
@@ -251,10 +254,8 @@ class FastImage
     Errno::ENETUNREACH, ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT,
     OpenSSL::SSL::SSLError
     raise ImageFetchFailure if @options[:raise_on_failure]
-  rescue NoMethodError  # 1.8.7p248 can raise this due to a net/http bug
-    raise ImageFetchFailure if @options[:raise_on_failure]
   rescue UnknownImageType
-    raise UnknownImageType if @options[:raise_on_failure]
+    raise if @options[:raise_on_failure]
   rescue CannotParseImage
     if @options[:raise_on_failure]
       if @property == :size
@@ -434,8 +435,11 @@ class FastImage
   end
 
   def fetch_using_base64(uri)
-    data = uri.split(',')[1]
-    decoded = Base64.decode64(data)
+    decoded = begin
+      Base64.decode64(uri.split(',')[1])
+    rescue
+      raise CannotParseImage
+    end
     @content_length = decoded.size
     fetch_using_read StringIO.new(decoded)
   end
@@ -471,19 +475,20 @@ class FastImage
 
     # Peeking beyond the end of the input will raise
     def peek(n)
-      while @strpos + n - 1 >= @str.size
+      while @strpos + n > @str.size
         unused_str = @str[@strpos..-1]
+
         new_string = @read_fiber.resume
+        new_string = @read_fiber.resume if new_string.is_a? Net::ReadAdapter
         raise CannotParseImage if !new_string
-
         # we are dealing with bytes here, so force the encoding
-        new_string.force_encoding("ASCII-8BIT") if String.method_defined? :force_encoding
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
 
         @str = unused_str + new_string
         @strpos = 0
       end
 
-      @str[@strpos..(@strpos + n - 1)]
+      @str[@strpos, n]
     end
 
     def read(n)
@@ -501,7 +506,7 @@ class FastImage
         new_string = @read_fiber.resume
         raise CannotParseImage if !new_string
 
-        new_string.force_encoding("ASCII-8BIT") if String.method_defined? :force_encoding
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
 
         fetched += new_string.size
         @str = new_string
@@ -536,8 +541,18 @@ class FastImage
     when '8B'
       :psd
     when "\0\0"
-      # ico has either a 1 (for ico format) or 2 (for cursor) at offset 3
       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 "ftypheic"
+          :heic
+        when "ftypmif1"
+          :heif
+        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
@@ -545,7 +560,7 @@ class FastImage
       :webp if @stream.peek(12)[8..11] == "WEBP"
     when "<s"
       :svg if @stream.peek(4) == "<svg"
-    when /<[?!]/
+    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 250 chars.
@@ -566,6 +581,179 @@ class FastImage
   end
   alias_method :parse_size_for_cur, :parse_size_for_ico
 
+  # 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:
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def width_and_height
+      @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
+      else
+        @final_size
+      end
+    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"
+          throw :finish
+        else
+          @stream.read(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 read_box_header!
+      size = read_uint32!
+      type = @stream.read(4)
+      [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
+  end
+
+  def parse_size_for_avif
+    bmff = IsoBmff.new(@stream)
+    bmff.width_and_height
+  end
+
+  def parse_size_for_heic
+    bmff = IsoBmff.new(@stream)
+    bmff.width_and_height
+  end
+
+  def parse_size_for_heif
+    bmff = IsoBmff.new(@stream)
+    bmff.width_and_height
+  end
+
   class Gif # :nodoc:
     def initialize(stream)
       @stream = stream
@@ -578,38 +766,45 @@ class FastImage
     # Checks if a delay between frames exists and if it does, then the GIFs is
     # animated
     def animated?
-      delay = 0
+      frames = 0
 
-      @stream.read(10) # "GIF" + version (3) + width (2) + height (2)
+      # "GIF" + version (3) + width (2) + height (2)
+      @stream.skip(10)
 
-      fields = @stream.read(3).unpack("C")[0] # fields (1) + bg color (1) + pixel ratio (1)
-
-      # Skip Global Color Table if it exists
-      if fields & 0x80
+      # 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
-          extension_type = @stream.read(1).unpack("C")[0]
-          size = @stream.read(1).unpack("C")[0]
-          if extension_type == 0xF9
-            delay = @stream.read(4).unpack("CSC")[1] # fields (1) + delay (2) + transparent index (1)
-            break
-          elsif extension_type == 0xFF
-            @stream.skip(size) # application ID (8) + version (3)
-          else
-            return # unrecognized extension
+
+        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
-          return # unrecognized block
+          break # unrecognized block
         end
       end
 
-      delay > 0
+      false
     end
 
     private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastimage
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.6
 platform: ruby
 authors:
 - Stephen Sykes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-23 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fakeweb-fi
@@ -77,6 +77,7 @@ files:
 - MIT-LICENSE
 - README.textile
 - lib/fastimage.rb
+- lib/fastimage/version.rb
 homepage: http://github.com/sdsykes/fastimage
 licenses:
 - MIT
@@ -97,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: FastImage - Image info fast