sdsykes-fastimage 0.1.0 → 1.0.1

data/README

@@ -1,27 +0,0 @@
-FastImage Resize is an extremely light solution for resizing images in ruby by using libgd
-
-=== Examples
-
-  require 'fastimage_resize'
-
-  FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", "my.gif", 100, 20)
-  => 1
-
-=== Requirements
-
-RubyInline
-
-  sudo gem install RubyInline
-
-FastImage
-
-  sudo gem install sdsykes-fastimage -s http://gems.github.com
-
-Libgd
-
-See http://www.libgd.org/
-Libgd is commonly available on most unix platforms, including OSX.
-
-=== References
-
-* http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing

data/README.textile

@@ -1,42 +1,38 @@
-h1. FastImage Resize
+h1. FastImage
 
-h4. FastImage Resize is an extremely light solution for resizing images in ruby by using libgd
+h4. FastImage finds the size or type of an image given its uri by fetching as little as needed
 
-h2. Examples
+h2. The problem
 
-<pre>
-<code>
-  require 'fastimage_resize'
+Your app needs to find the size or type of an image.  But the image is not locally stored - it's on another server, or in the cloud - at Amazon S3 for example.
 
-  FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", "my.gif", 100, 20)
-  => 1
-</pre>
-</code>
+You don't want to download the entire image, which 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 most of the image to find the size.
 
-h2. Requirements
+FastImage does this minimal fetch for image types GIF, JPEG, PNG and BMP.
 
-* RubyInline
+You only need supply the uri, and FastImage will do the rest.
 
-<pre>
-<code>
-  sudo gem install RubyInline
-</pre>
-</code>
-
-* FastImage
+h2. Examples
 
 <pre>
 <code>
-  sudo gem install sdsykes-fastimage -s http://gems.github.com
-</pre>
+require 'fastimage'
+
+FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
+=> [266, 56]  # width, height
+FastImage.type("http://stephensykes.com/images/pngimage")
+=> :png
 </code>
+</pre>
 
-* Libgd
+h2. Installation
 
-See "http://www.libgd.org/":http://www.libgd.org/
+h4. Gem
+
+  sudo gem install sdsykes-fastimage -s http://gems.github.com
 
-Libgd is commonly available on most unix platforms, including OSX.
+h2. Documentation
 
-h2. References
+"http://rdoc.info/projects/sdsykes/fastimage":http://rdoc.info/projects/sdsykes/fastimage
 
-* "http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing":http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing
+(c) 2009 Stephen Sykes (sdsykes)

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 0
-:major: 0
-:minor: 1
+:patch: 1
+:major: 1
+:minor: 0

data/lib/fastimage.rb

@@ -0,0 +1,252 @@
+# FastImage finds the size or type of an image given its uri.
+# It is careful to only fetch and parse as much of the image as is needed to determine the result.
+# It does this by using a feature of Net::HTTP that yields strings from the resource being fetched
+# as soon as the packets arrive.
+#
+# No external libraries such as ImageMagick are used here, this is a very lightweight solution to 
+# finding image information.
+#
+# FastImage knows about GIF, JPEG, BMP and PNG files.
+#
+# === Examples
+#   require 'fastimage'
+#
+#   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
+#   => [266, 56]
+#   FastImage.type("http://stephensykes.com/images/pngimage")
+#   => :png
+#
+# === 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.com/2008/08/19/find-jpeg-dimensions-fast-in-ruby/
+#
+require 'net/https'
+
+class FastImage
+  attr_reader :size, :type
+
+  class FastImageException < StandardError # :nodoc:
+  end
+  class MoreCharsNeeded < FastImageException # :nodoc:
+  end
+  class UnknownImageType < FastImageException # :nodoc:
+  end
+  class ImageFetchFailure < FastImageException # :nodoc:
+  end
+  class SizeNotFound < FastImageException # :nodoc:
+  end
+
+  DefaultTimeout = 2
+
+  # 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 the 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 and PNG files.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
+  #   => [266, 56]
+  #   FastImage.type("http://stephensykes.com/images/pngimage")
+  #   => [16, 16]
+  #   FastImage.size("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
+  #   => [500, 375]
+  #   FastImage.size("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
+  #   => [512, 512]
+  #   FastImage.size("http://pennysmalls.com/does_not_exist")
+  #   => nil
+  #   FastImage.size("http://pennysmalls.com/does_not_exist", :raise_on_failure=>true)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true)
+  #   => raises FastImage::UnknownImageType
+  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true, :timeout=>0.01)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://stephensykes.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 the 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("http://stephensykes.com/images/ss.com_x.gif")
+  #   => :gif
+  #   FastImage.type("http://stephensykes.com/images/pngimage")
+  #   => :png
+  #   FastImage.type("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
+  #   => :jpg
+  #   FastImage.type("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
+  #   => :bmp
+  #   FastImage.type("http://pennysmalls.com/does_not_exist")
+  #   => nil
+  #
+  # === 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.merge(:type_only=>true)).type
+  end
+
+  def initialize(uri, options={})
+    @type_only = options[:type_only]
+    setup_http(uri, options)
+    @http.request_get(@http_get_path) do |res|
+      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
+      fetch_size_from_response(res)
+    end
+    raise SizeNotFound if options[:raise_on_failure] && !@size
+  rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET, ImageFetchFailure
+    raise ImageFetchFailure if options[:raise_on_failure]
+  rescue UnknownImageType
+    raise UnknownImageType if options[:raise_on_failure]
+  end
+
+  private
+
+  def setup_http(uri, options)
+    u = URI.parse(uri)
+    @http = Net::HTTP.new(u.host, u.port)
+    @http.use_ssl = (u.scheme == "https")
+    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @http.open_timeout = options[:timeout] || DefaultTimeout
+    @http.read_timeout = options[:timeout] || DefaultTimeout
+    @http_get_path = u.request_uri
+  end
+
+  def fetch_type_from_response(res)
+    fetch_from_response(res, :type){parse_type}
+  end
+
+  def fetch_size_from_response(res)
+    fetch_from_response(res, :size){parse_size}
+  end
+
+  def fetch_from_response(res, item)
+    @unused_str = ""
+    res.read_body do |str|
+      @str = @unused_str + str
+      @strpos = 0
+      begin
+        result = yield
+        if result 
+          instance_variable_set("@#{item}", result)
+          break
+        end
+      rescue MoreCharsNeeded
+      end
+    end
+  end
+
+  def parse_size
+    @type = parse_type unless @type
+    send("parse_size_for_#{@type}")
+  end
+
+  def get_chars(n)
+    if @strpos + n - 1 >= @str.size
+      @unused_str = @str[@strpos..-1]
+      raise MoreCharsNeeded
+    else
+      result = @str[@strpos..(@strpos + n - 1)]
+      @strpos += n
+      result
+    end
+  end
+
+  def get_byte
+    get_chars(1).unpack("C")[0]
+  end
+
+  def read_int(str)
+    size_bytes = str.unpack("CC")
+    (size_bytes[0] << 8) + size_bytes[1]
+  end
+
+  def parse_type
+    case get_chars(2)
+    when "BM"
+      :bmp
+    when "GI"
+      :gif
+    when 0xff.chr + 0xd8.chr
+      :jpg
+    when 0x89.chr + "P"
+      :png
+    else
+      raise UnknownImageType
+    end
+  end
+
+  def parse_size_for_gif
+    get_chars(9)[4..8].unpack('SS')
+  end
+
+  def parse_size_for_png
+    get_chars(23)[14..22].unpack('NN')
+  end
+
+  def parse_size_for_jpg
+    loop do
+      @state = case @state
+      when nil
+        get_chars(2)
+        :started
+      when :started
+        get_byte == 0xFF ? :sof : :started          
+      when :sof
+        c = get_byte
+        if (0xe0..0xef).include?(c)
+          :skipframe
+        elsif [0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF].detect {|r| r.include? c}
+          :readsize
+        else
+          :skipframe
+        end
+      when :skipframe
+        @skip_chars = read_int(get_chars(2)) - 2
+        :do_skip
+      when :do_skip
+        get_chars(@skip_chars)
+        :started
+      when :readsize
+        s = get_chars(7)
+        return [read_int(s[5..6]), read_int(s[3..4])]
+      end
+    end
+  end
+
+  def parse_size_for_bmp
+    d = get_chars(27)[12..26]
+    d[0] == 40 ? d[4..-1].unpack('LL') : d[4..8].unpack('SS')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sdsykes-fastimage
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Stephen Sykes
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-08 00:00:00 -07:00
+date: 2009-06-11 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,8 +27,7 @@ files:
 - README
 - README.textile
 - VERSION.yml
-- lib/fastimage_resize.rb
-- test/test.rb
+- lib/fastimage.rb
 has_rdoc: true
 homepage: http://github.com/sdsykes/fastimage
 post_install_message: 

data/lib/fastimage_resize.rb

@@ -1,137 +0,0 @@
-# FastImage Resize is an extremely light solution for resizing images in ruby by using libgd
-#
-# === Examples
-#
-#   require 'fastimage_resize'
-#
-#   FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", "my.gif", 100, 20)
-#   => 1
-#
-# === Requirements
-#
-# RubyInline
-#
-#   sudo gem install RubyInline
-#
-# FastImage
-#
-#   sudo gem install sdsykes-fastimage -s http://gems.github.com
-#
-# Libgd
-#
-# See http://www.libgd.org/
-# Libgd is commonly available on most unix platforms, including OSX. 
-#
-# === References
-#
-# * http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing
-
-require 'inline'
-require 'open-uri'
-require 'tempfile'
-require 'fastimage'
-
-class FastImage
-  SUPPORTED_FORMATS = [:jpg, :png, :gif]
-
-  class FormatNotSupported < FastImageException # :nodoc:
-  end
-  
-  def self.resize(uri_in, file_out, w, h, options={})
-    jpeg_quality = options[:jpeg_quality] || -1
-    
-    u = URI.parse(uri_in)
-    if u.scheme == "http" || u.scheme == "https" || u.scheme == "ftp"
-      f = Tempfile.new(name)
-      f.write(open(u).read)
-      f.close
-      resize_local(f.path, file_out, w, h, jpeg_quality)
-      File.unlink(f.path)
-    else
-      resize_local(uri_in, file_out, w, h, jpeg_quality)
-    end
-  rescue OpenURI::HTTPError, SocketError
-    raise ImageFetchFailure
-  end
-
-  def self.resize_local(file_in, file_out, w, h, jpeg_quality)
-    fi = new(file_in, :raise_on_failure=>true, :type_only=>true)
-    type_index = SUPPORTED_FORMATS.index(fi.type)
-    raise FormatNotSupported unless type_index
-    fi.resize_image(file_in, file_out, w, h, type_index, jpeg_quality)
-  end
-
-  def resize_image(filename_in, filename_out, w, h, image_type, jpeg_quality); end
-  
-  inline do |builder|
-    builder.include '"gd.h"'
-    builder.add_link_flags "-lgd"
-    
-    builder.c <<-"END"
-      void resize_image(char *filename_in, char *filename_out, int w, int h, int image_type, int jpeg_quality) {
-        gdImagePtr im_in, im_out;
-        FILE *in, *out;
-        int trans, trans_r, trans_g, trans_b;
-        int x, y, f = 0;
-
-        in = fopen(filename_in, "rb");
-        if (!in) return;
-
-        im_out = gdImageCreateTrueColor(w, h);  /* must be truecolor */
-        switch(image_type) {
-          case 0: im_in = gdImageCreateFromJpeg(in);
-                  break;
-          case 1: im_in = gdImageCreateFromPng(in);
-                  gdImageAlphaBlending(im_out, 0);  /* handle transparency correctly */
-                  gdImageSaveAlpha(im_out, 1);
-                  break;
-          case 2: im_in = gdImageCreateFromGif(in);
-                  trans = gdImageGetTransparent(im_in);
-                  /* find a transparent pixel, then turn off transparency
-                     so that it copies correctly */
-                  if (trans >= 0) {
-                    for (x=0; x<gdImageSX(im_in); x++) {
-                      for (y=0; y<gdImageSY(im_in); y++) {
-                        if (gdImageGetPixel(im_in, x, y) == trans) {
-                          f = 1;
-                          break;
-                        }
-                      }
-                      if (f) break;
-                    }
-                    gdImageColorTransparent(im_in, -1);
-                    if (!f) trans = -1;  /* no transparent pixel found */
-                  }
-                  break;
-        }
-        
-        fclose(in);
-        
-        /* Now copy the original */
-        gdImageCopyResampled(im_out, im_in, 0, 0, 0, 0,
-          gdImageSX(im_out), gdImageSY(im_out),
-          gdImageSX(im_in), gdImageSY(im_in));
-
-        out = fopen(filename_out, "wb");
-        if (out) {
-          switch(image_type) {
-            case 0: gdImageJpeg(im_out, out, jpeg_quality);
-                    break;
-            case 1: gdImagePng(im_out, out);
-                    break;
-            case 2: gdImageTrueColorToPalette(im_out, 0, 256);
-                    if (trans >= 0) {
-                      trans = gdImageGetPixel(im_out, x, y);  /* get the color index of our transparent pixel */
-                      gdImageColorTransparent(im_out, trans); /* may not always work as hoped */
-                    }
-                    gdImageGif(im_out, out);
-                    break;
-          }
-          fclose(out);
-        }
-        gdImageDestroy(im_in);
-        gdImageDestroy(im_out);
-      }
-    END
-  end
-end

data/test/test.rb

@@ -1 +0,0 @@
-# todo