fastimage 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa0337307f5e98ae916e46768e148812f0f6dbb93a1c67d193ca981540779336
-  data.tar.gz: 8600c44df8eed5762ec526709d46e32841a099c0c453e7c255c2a87611dcb822
+  metadata.gz: f76a7f8a37bf8a8e98ea4d1e740a0df0d1248005bb143b2a0ffb5f6a27ad5ae5
+  data.tar.gz: 9b12393ce757e0628f298cb2919475ceeacd660dbf41f55fb98c8d0d3871e1d9
 SHA512:
-  metadata.gz: 57b4e77535ee1022ec9b1d3209536729dd5e980c2799fc6987d3c91731f5dd4dce3d93ef29f97c8762b6021b12795554efbc3ca1db7a49713aa119bdb5df5088
-  data.tar.gz: 83741942ce879586ae813fda60da760bee079ff1000dbbf7ee118b2513d579ae4cff8acf98de0bafe5313d429352053380e8d0293a101b0a3b1a799ce457f5a1
+  metadata.gz: 2bc5b3c37baafd7c2bf9bdddddc5464f2a1963c65e47a263b73e00251e3d763391e65afddc5fadf5fc87a76f6751e3c8b013c6578b32ff65a62cf885a4b2dafa
+  data.tar.gz: b1c2973319aa246147e80ad42776104e3317ca2f5e5ce154c512ad4157a9f1cc04d4ed1547031580f3252a14fd479c3a4cea671ff731b5739a5775565ca0af5d

data/README.md

@@ -13,7 +13,7 @@ But the image is not locally stored - it's on another asset server, or in the cl
 
 You don't want to download the entire image to your app server - it could be many tens of kilobytes, or even megabytes just to get this information. For most common image types (GIF, PNG, BMP etc.), the size of the image is simply stored at the start of the file. For JPEG files it's a little bit more complex, but even so you do not need to fetch much of the image to find the size.
 
-FastImage does this minimal fetch for image types GIF, JPEG, PNG, TIFF, BMP, ICO, CUR, PSD, SVG and WEBP. And it doesn't rely on installing external libraries such as RMagick (which relies on ImageMagick or GraphicsMagick) or ImageScience (which relies on FreeImage).
+FastImage does this minimal fetch for image types GIF, JPEG, PNG, TIFF, BMP, ICO, CUR, PSD, SVG, WEBP and JXL. And it doesn't rely on installing external libraries such as RMagick (which relies on ImageMagick or GraphicsMagick) or ImageScience (which relies on FreeImage).
 
 You only need supply the uri, and FastImage will do the rest.
 
@@ -96,38 +96,78 @@ http://sdsykes.github.io/fastimage/rdoc/FastImage.html
 
 ## Maintainer
 
-FastImage is maintained by Stephen Sykes (`sdsykes). Support this project by using [LibPixel](https://libpixel.com) cloud based image resizing and processing service.
+FastImage is maintained by Stephen Sykes (sdsykes). SamSaffron also helps out from time to time (thanks!).
 
 ## Benchmark
 
-It's way faster than conventional methods (for example the image_size gem) for most types of file when fetching over the wire.
+It's way faster than conventional methods for most types of file when fetching over the wire. Compared here by using OpenURI which will fetch the whole file.
 
 ```ruby
-irb> uri = "http://upload.wikimedia.org/wikipedia/commons/b/b4/Mardin_1350660_1350692_33_images.jpg"
-irb> puts Benchmark.measure {open(uri, 'rb') {|fh| p ImageSize.new(fh).size}}
+require 'benchmark'
+require 'fastimage'
+require 'open-uri'
+
+uri = "http://upload.wikimedia.org/wikipedia/commons/b/b4/Mardin_1350660_1350692_33_images.jpg"
+puts Benchmark.measure {URI.open(uri, 'rb') {|fh| p FastImage.size(fh)}}
 [9545, 6623]
-  0.680000   0.250000   0.930000 (  7.571887)
+  0.059088   0.067694   0.126782 (  0.808131)
 
-irb> puts Benchmark.measure {p FastImage.size(uri)}
+puts Benchmark.measure {p FastImage.size(uri)}
 [9545, 6623]
-  0.010000   0.000000   0.010000 (  0.090640)
+  0.006198   0.001563   0.007761 (  0.162021)
+```
+
+The file is fetched in about 0.8 seconds in this test (the number in brackets is the total time taken), but as FastImage doesn't need to fetch the whole thing, it completes in 0.16s.
+
+You'll see similar excellent results for the other file types.
+
+```ruby
+require 'benchmark'
+require 'fastimage'
+require 'open-uri'
+
+uri = "https://upload.wikimedia.org/wikipedia/commons/a/a9/Augustine_Herrman_1670_Map_Virginia_Maryland.tiff"
+puts Benchmark.measure {URI.open(uri, 'rb') {|fh| p FastImage.size(fh)}}
+[12805, 10204]
+  1.332587   2.049915   3.382502 ( 19.925270)
+
+puts Benchmark.measure {p FastImage.size(uri)}
+[12805, 10204]
+  0.004593   0.000924   0.005517 (  0.100592)
 ```
 
-The file is fetched in about 7.5 seconds in this test (the number in brackets is the total time taken), but as FastImage doesn't need to fetch the whole thing, it completes in less than 0.1s.
+Some tiff files however do not have their metadata near the start of the file.
 
-You'll see similar excellent results for the other file types, except for TIFF. Unfortunately TIFFs tend to have their
-metadata towards the end of the file, so it makes little difference to do a minimal fetch. The result shown below is
-mostly dependent on the exact internet conditions during the test, and little to do with the library used.
+```ruby
+require 'benchmark'
+require 'fastimage'
+require 'open-uri'
+
+uri = "https://upload.wikimedia.org/wikipedia/commons/1/14/Center-Filled_LIMA.tif"
+puts Benchmark.measure {URI.open(uri, 'rb') {|fh| p FastImage.size(fh)}}
+[22841, 19404]
+  0.350304   0.321104   0.671408 (  3.053605)
+
+puts Benchmark.measure {p FastImage.size(uri)}
+[22841, 19404]
+  0.163443   0.214301   0.377744 (  2.880414)
+```
+
+Note that if you want a really fast result for this file type, [image_size](https://github.com/toy/image_size?tab=readme-ov-file#experimental-fetch-image-meta-from-http-server) might be useful as it has an optimisation for this (fetching only the needed data range).
 
 ```ruby
-irb> uri = "http://upload.wikimedia.org/wikipedia/commons/1/11/Shinbutsureijoushuincho.tiff"
-irb> puts Benchmark.measure {open(uri, 'rb') {|fh| p ImageSize.new(fh).size}}
-[1120, 1559]
-  1.080000   0.370000   1.450000 ( 13.766962)
-
-irb> puts Benchmark.measure {p FastImage.size(uri)}
-[1120, 1559]
-  3.490000   3.810000   7.300000 ( 11.754315)
+require 'benchmark'
+require 'image_size/uri'
+require 'fastimage'
+
+uri = "https://upload.wikimedia.org/wikipedia/commons/1/14/Center-Filled_LIMA.tif"
+puts Benchmark.measure {p ImageSize.url(uri).size }
+[22841, 19404]
+  0.008983   0.001311   0.010294 (  0.128986)
+
+puts Benchmark.measure {p FastImage.size(uri)}
+[22841, 19404]
+  0.163443   0.214301   0.377744 (  2.880414)
 ```
 
 ## Tests
@@ -156,6 +196,10 @@ ruby test/test.rb
 - [Android by qstumn](https://github.com/qstumn/FastImageSize)
 - [Flutter by ky1vstar](https://github.com/ky1vstar/fastimage.dart)
 
+### Also of interest
+- [C++ by xiaozhuai](https://github.com/xiaozhuai/imageinfo)
+- [Rust by xiaozhuai](https://github.com/xiaozhuai/imageinfo-rs)
+
 ## Licence
 
 MIT, see file "MIT-LICENSE"

data/lib/fastimage/fastimage.rb

@@ -0,0 +1,471 @@
+require_relative 'fastimage_parsing/image_base'
+require_relative 'fastimage_parsing/stream_util'
+
+require_relative 'fastimage_parsing/avif'
+require_relative 'fastimage_parsing/bmp'
+require_relative 'fastimage_parsing/exif'
+require_relative 'fastimage_parsing/fiber_stream'
+require_relative 'fastimage_parsing/gif'
+require_relative 'fastimage_parsing/heic'
+require_relative 'fastimage_parsing/ico'
+require_relative 'fastimage_parsing/iso_bmff'
+require_relative 'fastimage_parsing/jpeg'
+require_relative 'fastimage_parsing/jxl'
+require_relative 'fastimage_parsing/jxlc'
+require_relative 'fastimage_parsing/png'
+require_relative 'fastimage_parsing/psd'
+require_relative 'fastimage_parsing/svg'
+require_relative 'fastimage_parsing/tiff'
+require_relative 'fastimage_parsing/type_parser'
+require_relative 'fastimage_parsing/webp'
+
+class FastImage
+  include FastImageParsing
+
+  attr_reader :bytes_read
+
+  class FastImageException < StandardError # :nodoc:
+  end
+  class UnknownImageType < FastImageException # :nodoc:
+  end
+  class ImageFetchFailure < FastImageException # :nodoc:
+  end
+  class SizeNotFound < FastImageException # :nodoc:
+  end
+  class CannotParseImage < FastImageException # :nodoc:
+  end
+  class BadImageURI < FastImageException # :nodoc:
+  end
+
+  DefaultTimeout = 2 unless const_defined?(:DefaultTimeout)
+
+  LocalFileChunkSize = 256 unless const_defined?(:LocalFileChunkSize)
+
+  private
+
+  Parsers = {
+    :bmp => Bmp,
+    :gif => Gif,
+    :jpeg => Jpeg,
+    :png => Png,
+    :tiff => Tiff,
+    :psd => Psd,
+    :heic => Heic,
+    :heif => Heic,
+    :webp => Webp,
+    :svg => Svg,
+    :ico => Ico,
+    :cur => Ico,
+    :jxl => Jxl,
+    :avif => Avif
+  }.freeze
+
+  public
+
+  SUPPORTED_IMAGE_TYPES = Parsers.keys.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.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot size the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # FastImage knows about GIF, JPEG, BMP, TIFF, ICO, CUR, PNG, HEIC/HEIF, AVIF, PSD, SVG, WEBP and JXL files.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.size("https://switchstep.com/images/ios.gif")
+  #   => [196, 283]
+  #   FastImage.size("http://switchstep.com/images/ss_logo.png")
+  #   => [300, 300]
+  #   FastImage.size("https://upload.wikimedia.org/wikipedia/commons/0/09/Jpeg_thumb_artifacts_test.jpg")
+  #   => [1280, 800]
+  #   FastImage.size("https://eeweb.engineering.nyu.edu/~yao/EL5123/image/lena_gray.bmp")
+  #   => [512, 512]
+  #   FastImage.size("test/fixtures/test.jpg")
+  #   => [882, 470]
+  #   FastImage.size("http://switchstep.com/does_not_exist")
+  #   => nil
+  #   FastImage.size("http://switchstep.com/does_not_exist", :raise_on_failure=>true)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://switchstep.com/images/favicon.ico", :raise_on_failure=>true)
+  #   => [16, 16]
+  #   FastImage.size("http://switchstep.com/foo.ics", :raise_on_failure=>true)
+  #   => raises FastImage::UnknownImageType
+  #   FastImage.size("http://switchstep.com/images/favicon.ico", :raise_on_failure=>true, :timeout=>0.01)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://switchstep.com/images/faulty.jpg", :raise_on_failure=>true)
+  #   => raises FastImage::SizeNotFound
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image size cannot be found for any reason.
+  #
+  def self.size(uri, options={})
+    new(uri, options).size
+  end
+
+  # Returns an symbol indicating the image type fetched from a uri.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.type("https://switchstep.com/images/ios.gif")
+  #   => :gif
+  #   FastImage.type("http://switchstep.com/images/ss_logo.png")
+  #   => :png
+  #   FastImage.type("https://upload.wikimedia.org/wikipedia/commons/0/09/Jpeg_thumb_artifacts_test.jpg")
+  #   => :jpeg
+  #   FastImage.type("https://eeweb.engineering.nyu.edu/~yao/EL5123/image/lena_gray.bmp")
+  #   => :bmp
+  #   FastImage.type("test/fixtures/test.jpg")
+  #   => :jpeg
+  #   FastImage.type("http://switchstep.com/does_not_exist")
+  #   => nil
+  #   File.open("/some/local/file.gif", "r") {|io| FastImage.type(io)}
+  #   => :gif
+  #   FastImage.type("test/fixtures/test.tiff")
+  #   => :tiff
+  #   FastImage.type("test/fixtures/test.psd")
+  #   => :psd
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
+  #
+  def self.type(uri, options={})
+    new(uri, options).type
+  end
+
+  # Returns a boolean value indicating the image is animated.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.animated?("test/fixtures/test.gif")
+  #   => false
+  #   FastImage.animated?("test/fixtures/animated.gif")
+  #   => true
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
+  #
+  def self.animated?(uri, options={})
+    new(uri, options).animated
+  end
+  
+  def initialize(uri, options={})
+    @uri = uri
+    @options = {
+      :timeout          => DefaultTimeout,
+      :raise_on_failure => false,
+      :proxy            => nil,
+      :http_header      => {}
+    }.merge(options)
+  end
+
+  def type
+    @property = :type
+    fetch unless defined?(@type)
+    @type
+  end
+
+  def size
+    @property = :size
+    begin
+      fetch unless defined?(@size)
+    rescue CannotParseImage
+    end
+
+    raise SizeNotFound if @options[:raise_on_failure] && !@size
+
+    @size
+  end
+
+  def orientation
+    size unless defined?(@size)
+    @orientation ||= 1 if @size
+  end
+
+  def width
+    size && @size[0]
+  end
+
+  def height
+    size && @size[1]
+  end
+
+  def animated
+    @property = :animated
+    fetch unless defined?(@animated)
+    @animated
+  end
+  
+  def content_length
+    @property = :content_length
+    fetch unless defined?(@content_length)
+    @content_length
+  end
+
+  # find an appropriate method to fetch the image according to the passed parameter
+  def fetch
+    raise BadImageURI if @uri.nil?
+
+    if @uri.respond_to?(:read)
+      fetch_using_read(@uri)
+    elsif @uri.start_with?('data:')
+      fetch_using_base64(@uri)
+    else
+      begin
+        @parsed_uri = URI.parse(@uri)
+      rescue URI::InvalidURIError
+        fetch_using_file_open
+      else
+        if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
+          fetch_using_http
+        else
+          fetch_using_file_open
+        end
+      end
+    end
+
+    raise SizeNotFound if @options[:raise_on_failure] && @property == :size && !@size
+
+  rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET,
+    Errno::ENETUNREACH, ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT,
+    OpenSSL::SSL::SSLError
+    raise ImageFetchFailure if @options[:raise_on_failure]
+  rescue UnknownImageType, BadImageURI, CannotParseImage
+    raise if @options[:raise_on_failure]
+  
+  ensure
+    @uri.rewind if @uri.respond_to?(:rewind)
+
+  end
+
+  private
+
+  def fetch_using_http
+    @redirect_count = 0
+
+    fetch_using_http_from_parsed_uri
+  end
+
+  # Some invalid locations need escaping
+  def escaped_location(location)
+    begin
+      URI(location)
+    rescue URI::InvalidURIError
+      ::URI::DEFAULT_PARSER.escape(location)
+    else
+      location
+    end
+  end
+
+  def fetch_using_http_from_parsed_uri
+    raise ImageFetchFailure unless @parsed_uri.is_a?(URI::HTTP)
+
+    http_header = {'Accept-Encoding' => 'identity'}.merge(@options[:http_header])
+
+    setup_http
+    @http.request_get(@parsed_uri.request_uri, http_header) do |res|
+      if res.is_a?(Net::HTTPRedirection) && @redirect_count < 4
+        @redirect_count += 1
+        begin
+          location = res['Location']
+          raise ImageFetchFailure if location.nil? || location.empty?
+
+          @parsed_uri = URI.join(@parsed_uri, escaped_location(location))
+        rescue URI::InvalidURIError
+        else
+          fetch_using_http_from_parsed_uri
+          break
+        end
+      end
+
+      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
+
+      @content_length = res.content_length
+      break if @property == :content_length
+
+      read_fiber = Fiber.new do
+        res.read_body do |str|
+          Fiber.yield str
+        end
+        nil
+      end
+
+      case res['content-encoding']
+      when 'deflate', 'gzip', 'x-gzip'
+        begin
+          gzip = Zlib::GzipReader.new(FiberStream.new(read_fiber))
+        rescue FiberError, Zlib::GzipFile::Error
+          raise CannotParseImage
+        end
+
+        read_fiber = Fiber.new do
+          while data = gzip.readline
+            Fiber.yield data
+          end
+          nil
+        end
+      end
+
+      parse_packets FiberStream.new(read_fiber)
+
+      break  # needed to actively quit out of the fetch
+    end
+  end
+
+  def protocol_relative_url?(url)
+    url.start_with?("//")
+  end
+
+  def proxy_uri
+    begin
+      if @options[:proxy]
+        proxy = URI.parse(@options[:proxy])
+      else
+        proxy = ENV['http_proxy'] && ENV['http_proxy'] != "" ? URI.parse(ENV['http_proxy']) : nil
+      end
+    rescue URI::InvalidURIError
+      proxy = nil
+    end
+    proxy
+  end
+
+  def setup_http
+    proxy = proxy_uri
+
+    if proxy
+      @http = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password).new(@parsed_uri.host, @parsed_uri.port)
+    else
+      @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
+    end
+    @http.use_ssl = (@parsed_uri.scheme == "https")
+    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @http.open_timeout = @options[:timeout]
+    @http.read_timeout = @options[:timeout]
+  end
+
+  def fetch_using_read(readable)
+    return @content_length = readable.size if @property == :content_length && readable.respond_to?(:size)
+
+    readable.rewind if readable.respond_to?(:rewind)
+    # Pathnames respond to read, but always return the first
+    # chunk of the file unlike an IO (even though the
+    # docuementation for it refers to IO). Need to supply
+    # an offset in this case.
+    if readable.is_a?(Pathname)
+      read_fiber = Fiber.new do
+        offset = 0
+        while str = readable.read(LocalFileChunkSize, offset)
+          Fiber.yield str
+          offset += LocalFileChunkSize
+        end
+        nil
+      end
+    else
+      read_fiber = Fiber.new do
+        while str = readable.read(LocalFileChunkSize)
+          Fiber.yield str
+        end
+        nil
+      end
+    end
+
+    parse_packets FiberStream.new(read_fiber)
+  end
+
+  def fetch_using_file_open
+    return @content_length = File.size?(@uri) if @property == :content_length
+
+    File.open(@uri) do |s|
+      fetch_using_read(s)
+    end
+  end
+
+  def fetch_using_base64(uri)
+    decoded = begin
+      uri.split(',')[1].unpack("m").first
+    rescue
+      raise CannotParseImage
+    end
+
+    fetch_using_read StringIO.new(decoded)
+  end
+  
+  def parse_packets(stream)
+    @stream = stream
+
+    begin
+      @type = TypeParser.new(@stream).type unless defined?(@type)
+
+      result = case @property
+      when :type
+        @type
+      when :size
+        parse_size
+      when :animated
+        parse_animated
+      end
+
+      if result != nil
+        # extract exif orientation if it was found
+        if @property == :size && result.size == 3
+          @orientation = result.pop
+        else
+          @orientation = 1
+        end
+
+        instance_variable_set("@#{@property}", result)
+      else
+        raise CannotParseImage
+      end
+    rescue FiberError
+      raise CannotParseImage
+    end
+  end
+
+  def parser_class
+    klass = Parsers[@type]
+    raise UnknownImageType unless klass
+    klass
+  end
+
+  def parse_size
+    parser_class.new(@stream).dimensions
+  end
+
+  def parse_animated
+    parser_class.new(@stream).animated?
+  end
+end

data/lib/fastimage/fastimage_parsing/avif.rb

@@ -0,0 +1,12 @@
+module FastImageParsing
+  class Avif < ImageBase # :nodoc:  
+    def dimensions
+      bmff = IsoBmff.new(@stream)
+      [bmff.width, bmff.height]
+    end
+  
+    def animated?
+      @stream.peek(12)[4..-1] == "ftypavis"
+    end
+  end
+end

data/lib/fastimage/fastimage_parsing/bmp.rb

@@ -0,0 +1,17 @@
+module FastImageParsing
+  class Bmp < ImageBase # :nodoc:
+    def dimensions
+      d = @stream.read(32)[14..28]
+      header = d.unpack("C")[0]
+
+      result = if header == 12
+                 d[4..8].unpack('SS')
+               else
+                 d[4..-1].unpack('l<l<')
+               end
+
+      # ImageHeight is expressed in pixels. The absolute value is necessary because ImageHeight can be negative
+      [result.first, result.last.abs]
+    end
+  end
+end