fastimage 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc7eb99ff0f61cddf103ac901c5bda2d37f83752
-  data.tar.gz: fccb0a33cfccefc1400c4d7c3c27a1124d2b6400
+  metadata.gz: af0ff2b0f792939e83294bbac7a348b5246f9021
+  data.tar.gz: 14737f78d877a431786c2e5bb437055a9dd01bdd
 SHA512:
-  metadata.gz: 000bc8011c9da184973abc60e5b119fd5a8ef8b1d3657cd80dd26ae12c67298d1dcd73ad7d2ed60c783be8d4542f1f57228e6c0b888ebb313499739173c5ec7b
-  data.tar.gz: fa02a8dfdaf54cc85e94fa468839b2c2fb718f35c4199959859109925f20c3fa63fcf6574fcce83c22a13cda94ccc4caed6f05eb82a907a635d4bc7f59c9fe55
+  metadata.gz: 1748c1570f833457b0c09ed075aa81b33bc702852ee23af7bab85118466e9b093584ae776bc30f0a846074e281e439e617eff544ed6cb3362aaa1f1922dd3c50
+  data.tar.gz: 2d31f722472a87b073a89413c301bce966dc30e8ff2f7926e276de39d0345facf5671b7fed373314df0aef7fa4e9caa76b8c86ca5c49ed5258beddde80762c2a

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2011 Stephen Sykes
+Copyright (c) 2008-2013 Stephen Sykes
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.textile

@@ -8,7 +8,7 @@ Your app needs to find the size or type of an image.  This could be for adding w
 
 But the image is not locally stored - it's on another asset server, or in the cloud - at Amazon S3 for example.
 
-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 image types, 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.
+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), 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 and BMP.  And it doesn't rely on installing external libraries such as RMagick (which relies on ImageMagick or GraphicsMagick) or ImageScience (which relies on FreeImage).
 
@@ -54,18 +54,46 @@ bc. gem install fastimage
 
 h4. Rails
 
-Install the gem as above, and add it to your Gemfile if you are using bundler, or configure it in your environment.rb file as below:
-<pre lang="ruby"><code>
-Rails::Initializer.run do |config|
-  config.gem "fastimage"
-end
-</code></pre>
+Install the gem as above, and add it to your Gemfile.
+
 Then you're off - just use @FastImage.size()@ and @FastImage.type()@ in your code as in the examples.
 
 h2. Documentation
 
 "http://sdsykes.github.io/fastimage/rdoc/FastImage.html":http://sdsykes.github.io/fastimage/rdoc/FastImage.html
 
+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.
+
+<pre lang="ruby"><code>
+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}}
+[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)
+</code></pre>
+
+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.
+
+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.
+
+<pre lang="ruby"><code>
+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)
+</code></pre>
+
 h2. Tests
 
 You'll need to @gem install fakeweb@ to be able to run the tests.

data/lib/fastimage.rb

@@ -173,6 +173,8 @@ 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, 
@@ -274,6 +276,7 @@ class FastImage
     @str.force_encoding("ASCII-8BIT") if has_encoding?
     @strpos = 0
     @bytes_read = 0
+    @bytes_delivered = 0
     
     begin
       result = send("parse_#{@property}")
@@ -290,6 +293,7 @@ class FastImage
   def parse_size
     @type = parse_type unless @type
     @strpos = 0
+    @bytes_delivered = 0
     send("parse_size_for_#{@type}")
   end
 
@@ -320,6 +324,7 @@ class FastImage
     
     result = @str[@strpos..(@strpos + n - 1)]
     @strpos += n
+    @bytes_delivered += n
     result
   end
 
@@ -369,6 +374,15 @@ class FastImage
         get_byte == 0xFF ? :sof : :started
       when :sof
         case get_byte
+        when 0xe1 # APP1
+          skip_chars = read_int(get_chars(2)) - 2
+          skip_from = @bytes_delivered
+          if get_chars(4) == "Exif"
+            get_chars(2)
+            parse_exif
+          end
+          get_chars(skip_chars - (@bytes_delivered - skip_from))
+          :started
         when 0xe0..0xef
           :skipframe
         when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF
@@ -379,14 +393,16 @@ class FastImage
           :skipframe
         end
       when :skipframe
-        @skip_chars = read_int(get_chars(2)) - 2
-        :do_skip
-      when :do_skip
-        get_chars(@skip_chars)
+        skip_chars = read_int(get_chars(2)) - 2
+        get_chars(skip_chars)
         :started
       when :readsize
         s = get_chars(7)
-        return [read_int(s[5..6]), read_int(s[3..4])]
+        if @exif_orientation && @exif_orientation >= 5
+          return [read_int(s[3..4]), read_int(s[5..6])]
+        else
+          return [read_int(s[5..6]), read_int(s[3..4])]
+        end          
       end
     end
   end
@@ -396,36 +412,67 @@ class FastImage
     d.unpack("C")[0] == 40 ? d[4..-1].unpack('LL') : d[4..8].unpack('SS')
   end
 
-  def parse_size_for_tiff
+  def get_exif_byte_order
     byte_order = get_chars(2)
     case byte_order
-      when 'II'; short, long = 'v', 'V'
-      when 'MM'; short, long = 'n', 'N'
+    when 'II'
+      @short, @long = 'v', 'V'
+    when 'MM'
+      @short, @long = 'n', 'N'
+    else
+      raise CannotParseImage
     end
-    get_chars(2) # 42
-
-    offset = get_chars(4).unpack(long)[0]
-    get_chars(offset - 8)
-
-    width = height = nil
+  end
 
-    tag_count = get_chars(2).unpack(short)[0]
+  def parse_exif_ifd
+    tag_count = get_chars(2).unpack(@short)[0]
     tag_count.downto(1) do
-      type = get_chars(2).unpack(short)[0]
+      type = get_chars(2).unpack(@short)[0]
       get_chars(6)
-      data = get_chars(2).unpack(short)[0]
+      data = get_chars(2).unpack(@short)[0]
       case type
       when 0x0100 # image width
-        width = data
+        @exif_width = data
       when 0x0101 # image height
-        height = data
+        @exif_height = data
+      when 0x0112 # orientation
+        @exif_orientation = data
       end
-      if width && height
-        return [width, height]
+      if @type == :tiff && @exif_width && @exif_height && @exif_orientation
+        return # no need to parse more
       end
       get_chars(2)
     end
+
+    next_offset = get_chars(4).unpack(@long)[0]
+    if next_offset > 0
+      get_chars(next_offset - (@bytes_delivered - @exif_start_byte))
+      parse_exif_ifd
+    end
+  end
+
+  def parse_exif
+    @exif_start_byte = @bytes_delivered
+    
+    get_exif_byte_order
     
+    get_chars(2) # 42
+
+    offset = get_chars(4).unpack(@long)[0]
+    get_chars(offset - 8)
+
+    parse_exif_ifd
+  end
+
+  def parse_size_for_tiff
+    parse_exif
+
+    if @exif_orientation && @exif_orientation >= 5
+      return [@exif_height, @exif_width]
+    else
+      return [@exif_width, @exif_height]
+    end
+
     raise CannotParseImage
   end
 end

data/test/test.rb

@@ -18,7 +18,8 @@ GoodFixtures = {
   "test2.jpg"=>[:jpeg, [250, 188]],
   "test3.jpg"=>[:jpeg, [630, 367]],
   "test.tiff"=>[:tiff, [85, 67]],
-  "test2.tiff"=>[:tiff, [333, 225]]
+  "test2.tiff"=>[:tiff, [333, 225]],
+  "exif_orientation.jpg"=>[:jpeg, [2448, 3264]]
   }
 
 BadFixtures = [
@@ -123,6 +124,15 @@ class FastImageTest < Test::Unit::TestCase
       end
     end
   end
+  
+  def test_should_report_size_correctly_on_io_object_twice
+    GoodFixtures.each do |fn, info|
+      File.open(File.join(FixturePath, fn), "r") do |io|
+        assert_equal info[1], FastImage.size(io)
+        assert_equal info[1], FastImage.size(io)
+      end
+    end
+  end
 
   def test_should_report_size_correctly_for_local_files_with_path_that_has_spaces
     Dir.chdir(PathHere) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastimage
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Stephen Sykes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-08 00:00:00.000000000 Z
+date: 2013-07-02 00:00:00.000000000 Z
 dependencies: []
 description: FastImage finds the size or type of an image given its uri by fetching
   as little as needed.
@@ -32,10 +32,12 @@ files:
 - test/fixtures/test3.jpg
 - test/fixtures/test.tiff
 - test/fixtures/test2.tiff
+- test/fixtures/exif_orientation.jpg
 - test/fixtures/folder with spaces/test.bmp
 - test/test.rb
 homepage: http://github.com/sdsykes/fastimage
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: