fastimage 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4eedb99b6314f24fb47381046bf63595b90b8eb8045a6b9b238a92acebc00ba
-  data.tar.gz: 10db6080223fb596a5fcfc904563a5f25b8209af1c4166260831e7aef9d7613e
+  metadata.gz: f76a7f8a37bf8a8e98ea4d1e740a0df0d1248005bb143b2a0ffb5f6a27ad5ae5
+  data.tar.gz: 9b12393ce757e0628f298cb2919475ceeacd660dbf41f55fb98c8d0d3871e1d9
 SHA512:
-  metadata.gz: eae9ad37f27b853c2927183802b015ca6a066e413a112d80bb119603944d07d9fba5aac36712bc12c12acb327e3031a6b8c6875120e6f8de501e0526d4e2be14
-  data.tar.gz: 2b8e2add3af30fe7e856b84e18ba6f9425fb939e5e789f1601fb360abb91ee5197b15adaa6cff79a2bdb89ea7a9d95306ebc0513c4882cd0a30b7ab3261173d2
+  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.
 
@@ -196,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

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