fastimage 1.8.1 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 14c971688e6b8e577baf835c98f64700081af0bd
-  data.tar.gz: 25ffa6572caf216c99a7dcfbdc2a1d6cc5a40b2e
+SHA256:
+  metadata.gz: 4124655c4f8af69e9b8bf9bfa433a11161e9ea97c23e755a196555012eadf75b
+  data.tar.gz: 40fef6aa908fc14799f2cb53e80d5081bef11ce0482d86c5947841fb29ee9604
 SHA512:
-  metadata.gz: 7ae55b045d02d4c1a7ce3452ed3da248e01312a9059bbef29c6e57a780a53ba0874c1566b9703b0ddb143e12d7827609194fa52b151cbe5a30861c2e6644c685
-  data.tar.gz: 15c0ee070dc9f516592445a29ae66c2c38f5b93a1572c5befa68a3d9227806a7345840ed8a88c1352b8a307ed0fa7b6224efa0d19d219f92d708863347fffda8
+  metadata.gz: 205fb43dacd3239f8425dd8cbd311be8c375f3c377cbf71771b87304b0c62780905a366783b1b5606e7386edf9ed2fe1cab138b8a20ad47f238150d5143b93db
+  data.tar.gz: 219ac67b55c23bb59458fc57d165a76c0bf5855c971c705d033103c01848cbb9f3fb4a1e8024419192ced93f076d223fb6e3ce77289b8ed94858d0e58c5387df

data/README.textile

@@ -1,4 +1,5 @@
-!https://travis-ci.org/sdsykes/fastimage.png?branch=master!:https://travis-ci.org/sdsykes/fastimage
+!https://img.shields.io/gem/dt/fastimage.svg!:https://rubygems.org/gems/fastimage
+!https://travis-ci.org/sdsykes/fastimage.svg?branch=master!:https://travis-ci.org/sdsykes/fastimage
 
 h1. FastImage
 
@@ -18,27 +19,29 @@ You only need supply the uri, and FastImage will do the rest.
 
 h2. Features
 
-Fastimage can also read local (and other) files - anything that is not parseable as a URI will be
-interpreted as a filename, and FastImage will attempt to open it with File#open.
+FastImage can also read local (and other) files - anything that is not parseable as a URI will be interpreted as a filename, and FastImage will attempt to open it with @File#open@.
 
-FastImage will also automatically read from any object that responds to :read - for
-instance an IO object if that is passed instead of a URI.
+FastImage will also automatically read from any object that responds to @:read@ - for instance an IO object if that is passed instead of a URI.
 
 FastImage will follow up to 4 HTTP redirects to get the image.
 
-FastImage will obey the http_proxy setting in your environment to route requests via a proxy. You can also pass a :proxy argument if you want to specify the proxy address in the call.
+FastImage will obey the @http_proxy@ setting in your environment to route requests via a proxy. You can also pass a @:proxy@ argument if you want to specify the proxy address in the call.
 
-You can add a timeout to the request which will limit the request time by passing :timeout => number_of_seconds.
+You can add a timeout to the request which will limit the request time by passing @:timeout => number_of_seconds@.
 
-FastImage normally replies will nil if it encounters an error, but you can pass :raise_on_failure => true to get an exception.
+FastImage normally replies with @nil@ if it encounters an error, but you can pass @:raise_on_failure => true@ to get an exception.
 
 FastImage also provides a reader for the content length header provided in HTTP. This may be useful to assess the file size of an image, but do not rely on it exclusively - it will not be present in chunked responses for instance.
 
-FastImage accepts additional HTTP headers. This can be used to set a user agent or referrer which some servers require. Pass an :http_header argument to specify headers, e.g., :http_header => {'User-Agent' => 'Fake Browser'}.
+FastImage accepts additional HTTP headers. This can be used to set a user agent or referrer which some servers require. Pass an @:http_header@ argument to specify headers, e.g., @:http_header => {'User-Agent' => 'Fake Browser'}@.
+
+FastImage can give you information about the parsed display orientation of an image with Exif data (jpeg or tiff).
+
+FastImage also handles "Data URIs":https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs correctly.
 
 h2. Security
 
-As of v1.6.7 FastImage no longer uses openuri to open files, but directly calls File.open. But take care to sanitise the strings passed to FastImage; it will try to read from whatever is passed.
+As of v1.6.7 FastImage no longer uses @openuri@ to open files, but directly calls @File.open@. Take care to sanitise the strings passed to FastImage; it will try to read from whatever is passed.
 
 h2. Examples
 
@@ -59,10 +62,20 @@ FastImage.new("http://stephensykes.com/images/pngimage").content_length
 => 432
 FastImage.size("http://stephensykes.com/images/ss.com_x.gif", :http_header => {'User-Agent' => 'Fake Browser'})
 => [266, 56]
+FastImage.new("http://stephensykes.com/images/ExifOrientation3.jpg").orientation
+=> 3
+FastImage.size("data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==")
+=> [1, 1]
 </code></pre>
 
 h2. Installation
 
+h4. Required Ruby version
+
+FastImage version 2.0.0 and above work with Ruby 1.9.2 and above.
+
+FastImage version 1.9.0 was the last version that supported Ruby 1.8.7.
+
 h4. Gem
 
 bc. gem install fastimage
@@ -79,6 +92,10 @@ h2. Documentation
 
 "http://sdsykes.github.io/fastimage/rdoc/FastImage.html":http://sdsykes.github.io/fastimage/rdoc/FastImage.html
 
+h2. Maintainer
+
+FastImage is maintained by Stephen Sykes (@sdsykes). Support this project by using "LibPixel":https://libpixel.com cloud based image resizing and processing service.
+
 h2. Benchmark
 
 It's way faster than conventional methods (for example the image_size gem) for most types of file when fetching over the wire.
@@ -88,7 +105,7 @@ irb> uri = "http://upload.wikimedia.org/wikipedia/commons/b/b4/Mardin_1350660_13
 irb> puts Benchmark.measure {open(uri, 'rb') {|fh| p ImageSize.new(fh).size}}
 [9545, 6623]
   0.680000   0.250000   0.930000 (  7.571887)
-  
+
 irb> puts Benchmark.measure {p FastImage.size(uri)}
 [9545, 6623]
   0.010000   0.000000   0.010000 (  0.090640)
@@ -105,7 +122,7 @@ irb> uri = "http://upload.wikimedia.org/wikipedia/commons/1/11/Shinbutsureijoush
 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)
@@ -115,18 +132,17 @@ 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 
-Run options: 
+bc.. $ ruby test/test.rb
+Run options:
 
 # Running tests:
 
-Finished tests in 1.033640s, 23.2189 tests/s, 82.2337 assertions/s.             
+Finished tests in 1.033640s, 23.2189 tests/s, 82.2337 assertions/s.
 24 tests, 85 assertions, 0 failures, 0 errors, 0 skips
 
 h2. References
 
 * "Pennysmalls - Find jpeg dimensions fast in pure Ruby, no image library needed":http://pennysmalls.wordpress.com/2008/08/19/find-jpeg-dimensions-fast-in-pure-ruby-no-ima/
-* "DZone - Determine Image Size":http://snippets.dzone.com/posts/show/805
 * "Antti Kupila - Getting JPG dimensions with AS3 without loading the entire file":http://www.anttikupila.com/flash/getting-jpg-dimensions-with-as3-without-loading-the-entire-file/
 * "imagesize gem":https://rubygems.org/gems/imagesize
 * "EXIF Reader":https://github.com/remvee/exifr
@@ -139,22 +155,9 @@ h2. FastImage in other languages
 * "PHP by tommoor":https://github.com/tommoor/fastimage
 * "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
 
 MIT, see file "MIT-LICENSE":MIT-LICENSE
-
-h2. Contributors
-
-Pull requests and suggestions are always welcome. Thanks to all the contributors!
-
-* @felixbuenemann
-* @speedmax
-* @sebastianludwig
-* @benjaminjackson
-* @muffinista
-* @marcandre
-* @apanzerj
-* @forresty
-* kikihakiem
-* lulalalalistia

data/lib/fastimage.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # coding: ASCII-8BIT
 
 # FastImage finds the size or type of an image given its uri.
@@ -28,6 +29,9 @@
 # or referrer which some servers require. Pass an :http_header argument to specify headers,
 # e.g., :http_header => {'User-Agent' => 'Fake Browser'}.
 #
+# FastImage can give you information about the parsed display orientation of an image with Exif
+# data (jpeg or tiff).
+#
 # === Examples
 #   require 'fastimage'
 #
@@ -39,9 +43,12 @@
 #   => :gif
 #   File.open("/some/local/file.gif", "r") {|io| FastImage.type(io)}
 #   => :gif
+#   FastImage.new("http://stephensykes.com/images/pngimage").content_length
+#   => 432
+#   FastImage.new("http://stephensykes.com/images/ExifOrientation3.jpg").orientation
+#   => 3
 #
 # === References
-# * http://snippets.dzone.com/posts/show/805
 # * http://www.anttikupila.com/flash/getting-jpg-dimensions-with-as3-without-loading-the-entire-file/
 # * http://pennysmalls.wordpress.com/2008/08/19/find-jpeg-dimensions-fast-in-pure-ruby-no-ima/
 # * https://rubygems.org/gems/imagesize
@@ -49,14 +56,21 @@
 #
 
 require 'net/https'
-require 'addressable/uri'
-require 'fastimage/fbr.rb'
 require 'delegate'
 require 'pathname'
 require 'zlib'
+require 'base64'
+require 'uri'
+
+# see http://stackoverflow.com/questions/5208851/i/41048816#41048816
+if RUBY_VERSION < "2.2"
+  module URI
+    DEFAULT_PARSER = Parser.new(:HOSTNAME => "(?:(?:[a-zA-Z\\d](?:[-\\_a-zA-Z\\d]*[a-zA-Z\\d])?)\\.)*(?:[a-zA-Z](?:[-\\_a-zA-Z\\d]*[a-zA-Z\\d])?)\\.?")
+  end
+end
 
 class FastImage
-  attr_reader :size, :type, :content_length
+  attr_reader :size, :type, :content_length, :orientation, :animated
 
   attr_reader :bytes_read
 
@@ -165,6 +179,34 @@ class FastImage
     new(uri, options.merge(:type_only=>true)).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.merge(:animated_only=>true)).animated
+  end
+
   def initialize(uri, options={})
     @uri = uri
     @options = {
@@ -175,14 +217,24 @@ class FastImage
       :http_header      => {}
     }.merge(options)
 
-    @property = @options[:type_only] ? :type : :size
+    @property = if @options[:animated_only]
+      :animated
+    elsif @options[:type_only]
+      :type
+    else
+      :size
+    end
+
+    @type, @state = nil
 
     if uri.respond_to?(:read)
       fetch_using_read(uri)
+    elsif uri.start_with?('data:')
+      fetch_using_base64(uri)
     else
       begin
-        @parsed_uri = Addressable::URI.parse(uri)
-      rescue Addressable::URI::InvalidURIError
+        @parsed_uri = URI.parse(uri)
+      rescue URI::InvalidURIError
         fetch_using_file_open
       else
         if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
@@ -193,17 +245,14 @@ class FastImage
       end
     end
 
-    uri.rewind if uri.respond_to?(:rewind)
-
     raise SizeNotFound if @options[:raise_on_failure] && @property == :size && !@size
 
   rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET,
-    ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT
-    raise ImageFetchFailure if @options[:raise_on_failure]
-  rescue NoMethodError  # 1.8.7p248 can raise this due to a net/http bug
+    Errno::ENETUNREACH, ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT,
+    OpenSSL::SSL::SSLError
     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
@@ -213,6 +262,9 @@ class FastImage
       end
     end
 
+  ensure
+    uri.rewind if uri.respond_to?(:rewind)
+
   end
 
   private
@@ -223,6 +275,17 @@ class FastImage
     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
     http_header = {'Accept-Encoding' => 'identity'}.merge(@options[:http_header])
 
@@ -231,14 +294,11 @@ class FastImage
       if res.is_a?(Net::HTTPRedirection) && @redirect_count < 4
         @redirect_count += 1
         begin
-          newly_parsed_uri = Addressable::URI.parse(res['Location'])
-          # The new location may be relative - check for that
-          if newly_parsed_uri.scheme != "http" && newly_parsed_uri.scheme != "https"
-            @parsed_uri.path = res['Location']
-          else
-            @parsed_uri = newly_parsed_uri
-          end
-        rescue Addressable::URI::InvalidURIError
+          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
@@ -276,14 +336,18 @@ class FastImage
     end
   end
 
+  def protocol_relative_url?(url)
+    url.start_with?("//")
+  end
+
   def proxy_uri
     begin
       if @options[:proxy]
-        proxy = Addressable::URI.parse(@options[:proxy])
+        proxy = URI.parse(@options[:proxy])
       else
-        proxy = ENV['http_proxy'] && ENV['http_proxy'] != "" ? Addressable::URI.parse(ENV['http_proxy']) : nil
+        proxy = ENV['http_proxy'] && ENV['http_proxy'] != "" ? URI.parse(ENV['http_proxy']) : nil
       end
-    rescue Addressable::URI::InvalidURIError
+    rescue URI::InvalidURIError
       proxy = nil
     end
     proxy
@@ -293,9 +357,9 @@ class FastImage
     proxy = proxy_uri
 
     if proxy
-      @http = Net::HTTP::Proxy(proxy.host, proxy.port).new(@parsed_uri.host, @parsed_uri.inferred_port)
+      @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.inferred_port)
+      @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
@@ -304,6 +368,7 @@ class FastImage
   end
 
   def fetch_using_read(readable)
+    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
@@ -328,6 +393,7 @@ class FastImage
   end
 
   def fetch_using_file_open
+    @content_length = File.size?(@uri)
     File.open(@uri) do |s|
       fetch_using_read(s)
     end
@@ -338,7 +404,14 @@ class FastImage
 
     begin
       result = send("parse_#{@property}")
-      if result
+      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
@@ -353,6 +426,21 @@ class FastImage
     send("parse_size_for_#{@type}")
   end
 
+  def parse_animated
+    @type = parse_type unless @type
+    @type == :gif ? send("parse_animated_for_#{@type}") : nil
+  end
+
+  def fetch_using_base64(uri)
+    decoded = begin
+      Base64.decode64(uri.split(',')[1])
+    rescue
+      raise CannotParseImage
+    end
+    @content_length = decoded.size
+    fetch_using_read StringIO.new(decoded)
+  end
+
   module StreamUtil # :nodoc:
     def read_byte
       read(1)[0].ord
@@ -382,20 +470,22 @@ class FastImage
       @str = ''
     end
 
+    # 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
 
-      result = @str[@strpos..(@strpos + n - 1)]
+      @str[@strpos, n]
     end
 
     def read(n)
@@ -404,6 +494,24 @@ class FastImage
       @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 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
 
   class IOStream < SimpleDelegator # :nodoc:
@@ -411,7 +519,7 @@ class FastImage
   end
 
   def parse_type
-    case @stream.peek(2)
+    parsed_type = case @stream.peek(2)
     when "BM"
       :bmp
     when "GI"
@@ -421,7 +529,12 @@ class FastImage
     when 0x89.chr + "P"
       :png
     when "II", "MM"
-      :tiff
+      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 "\0\0"
@@ -431,31 +544,100 @@ class FastImage
       when 2 then :cur
       end
     when "RI"
-      if @stream.peek(12)[8..11] == "WEBP"
-        :webp
-      else
-        raise UnknownImageType
-      end
+      :webp if @stream.peek(12)[8..11] == "WEBP"
     when "<s"
-      :svg
-    when "<?"
-      if @stream.peek(100).include?("<svg")
-        :svg
-      else
-        raise UnknownImageType
+      :svg if @stream.peek(4) == "<svg"
+    when /\s\s|\s<|<[?!]/
+      # 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.
+      begin
+        :svg if (1..25).detect {|n| @stream.peek(10 * n).include?("<svg")}
+      rescue FiberError
+        nil
       end
-    else
-      raise UnknownImageType
     end
+
+    parsed_type or raise UnknownImageType
   end
 
   def parse_size_for_ico
-    @stream.read(8)[6..7].unpack('CC').map{|byte| byte == 0 ? 256 : byte }
+    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
   alias_method :parse_size_for_cur, :parse_size_for_ico
 
+  class Gif # :nodoc:
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def width_and_height
+      @stream.read(11)[6..10].unpack('SS')
+    end
+
+    # Checks if a delay between frames exists and if it does, then the GIFs is
+    # animated
+    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
+
   def parse_size_for_gif
-    @stream.read(11)[6..10].unpack('SS')
+    gif = Gif.new(@stream)
+    gif.width_and_height
   end
 
   def parse_size_for_png
@@ -463,10 +645,11 @@ class FastImage
   end
 
   def parse_size_for_jpeg
+    exif = nil
     loop do
       @state = case @state
       when nil
-        @stream.read(2)
+        @stream.skip(2)
         :started
       when :started
         @stream.read_byte == 0xFF ? :sof : :started
@@ -478,7 +661,8 @@ class FastImage
           io = StringIO.new(data)
           if io.read(4) == "Exif"
             io.read(2)
-            @exif = Exif.new(IOStream.new(io)) rescue nil
+            new_exif = Exif.new(IOStream.new(io)) rescue nil
+            exif ||= new_exif # only use the first APP1 segment
           end
           :started
         when 0xe0..0xef
@@ -492,14 +676,14 @@ class FastImage
         end
       when :skipframe
         skip_chars = @stream.read_int - 2
-        @stream.read(skip_chars)
+        @stream.skip(skip_chars)
         :started
       when :readsize
-        s = @stream.read(3)
+        @stream.skip(3)
         height = @stream.read_int
         width = @stream.read_int
-        width, height = height, width if @exif && @exif.rotated?
-        return [width, height]
+        width, height = height, width if exif && exif.rotated?
+        return [width, height, exif ? exif.orientation : 1]
       end
     end
   end
@@ -508,10 +692,10 @@ class FastImage
     d = @stream.read(32)[14..28]
     header = d.unpack("C")[0]
 
-    result = if header == 40
-               d[4..-1].unpack('l<l<')
-             else
+    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
@@ -520,7 +704,7 @@ class FastImage
 
   def parse_size_for_webp
     vp8 = @stream.read(16)[12..15]
-    len = @stream.read(4).unpack("V")
+    _len = @stream.read(4).unpack("V")
     case vp8
     when "VP8 "
       parse_size_vp8
@@ -539,7 +723,7 @@ class FastImage
   end
 
   def parse_size_vp8l
-    @stream.read(1) # 0x2f
+    @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
@@ -558,14 +742,16 @@ class FastImage
   end
 
   class Exif # :nodoc:
-    attr_reader :width, :height
+    attr_reader :width, :height, :orientation
+
     def initialize(stream)
       @stream = stream
+      @width, @height, @orientation = nil
       parse_exif
     end
 
     def rotated?
-      @orientation && @orientation >= 5
+      @orientation >= 5
     end
 
     private
@@ -611,9 +797,15 @@ class FastImage
       @stream.read(2) # 42
 
       offset = @stream.read(4).unpack(@long)[0]
-      @stream.read(offset - 8)
+      if @stream.respond_to?(:skip)
+        @stream.skip(offset - 8)
+      else
+        @stream.read(offset - 8)
+      end
 
       parse_exif_ifd
+
+      @orientation ||= 1
     end
 
   end
@@ -621,9 +813,9 @@ class FastImage
   def parse_size_for_tiff
     exif = Exif.new(@stream)
     if exif.rotated?
-      [exif.height, exif.width]
+      [exif.height, exif.width, exif.orientation]
     else
-      [exif.width, exif.height]
+      [exif.width, exif.height, exif.orientation]
     end
   end
 
@@ -634,6 +826,7 @@ class FastImage
   class Svg # :nodoc:
     def initialize(stream)
       @stream = stream
+      @width, @height, @ratio, @viewbox_width, @viewbox_height = nil
       parse_svg
     end
 
@@ -644,6 +837,10 @@ class FastImage
         [@width, @width / @ratio]
       elsif @height && @ratio
         [@height * @ratio, @height]
+      elsif @viewbox_width && @viewbox_height
+        [@viewbox_width, @viewbox_height]
+      else
+        nil
       end
     end
 
@@ -666,14 +863,20 @@ class FastImage
             return if @width
           elsif attr_name.join =~ /viewbox/i
             values = attr_value.split(/\s/)
-            @ratio = values[2].to_f / values[3].to_f
+            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"
+          state = :started if attr_name.join == "<svg"
           attr_name.clear
         end
       end
@@ -694,4 +897,9 @@ class FastImage
     svg = Svg.new(@stream)
     svg.width_and_height
   end
+
+  def parse_animated_for_gif
+    gif = Gif.new(@stream)
+    gif.animated?
+  end
 end