Add support for C++11 on Mac

Version bumps
Small doc improvements ahead of v0.6.0
2026-02-04 21:56:18 +01:00 · 2014-08-24 21:41:09 +01:00 · 2014-08-24 21:40:23 +01:00 · 2014-08-22 16:57:05 +01:00 · 2014-08-22 16:50:24 +01:00 · 2014-08-22 14:31:34 +01:00
18 changed files with 2675 additions and 357 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -12,7 +12,4 @@ logs
 results
 build
 node_modules
-tests/output.jpg
-tests/output.png
-
-npm-debug.log
+tests/fixtures/output.*
--- a/.npmignore
+++ b/.npmignore
@@ -0,0 +1,18 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+
+pids
+logs
+results
+build
+node_modules
+
+.gitignore
+tests
+.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,17 @@
+language: node_js
+node_js:
+  - "0.10"
+  - "0.11"
+before_install:
+  - sudo add-apt-repository ppa:lyrasis/precise-backports -y
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq automake gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-turbo8-dev libpng12-dev libwebp-dev libtiff4-dev libexif-dev libxml2-dev swig graphicsmagick libmagick++-dev
+  - git clone https://github.com/jcupitt/libvips.git
+  - cd libvips
+  - git checkout 7.38
+  - ./bootstrap.sh
+  - ./configure --enable-debug=no --enable-cxx=yes --without-orc --without-python --without-fftw
+  - make
+  - sudo make install
+  - sudo ldconfig
+  - cd $TRAVIS_BUILD_DIR
--- a/README.md
+++ b/README.md
@@ -1,44 +1,91 @@
-# sharp
+# sharp

-_adj_
+* [Installation](https://github.com/lovell/sharp#installation)
+* [Usage examples](https://github.com/lovell/sharp#usage-examples)
+* [API](https://github.com/lovell/sharp#api)
+* [Testing](https://github.com/lovell/sharp#testing)
+* [Performance](https://github.com/lovell/sharp#performance)
+* [Licence](https://github.com/lovell/sharp#licence)

-1. clearly defined; distinct: a sharp photographic image. 
-2. quick, brisk, or spirited. 
-3. shrewd or astute: a sharp bargainer. 
-4. (Informal.) very stylish: a sharp dresser; a sharp jacket. 
+The typical use case for this high speed Node.js module is to convert large images of many formats to smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.

-The typical use case for this high speed Node.js module is to convert large JPEG and PNG images to smaller JPEG and PNG images of varying dimensions.
+The performance of JPEG resizing is typically 8x faster than ImageMagick and GraphicsMagick, based mainly on the number of CPU cores available.

-It is somewhat opinionated in that it only deals with JPEG and PNG images, always obeys the requested dimensions by either cropping or embedding and insists on a mild sharpen of the resulting image.
+Memory usage is kept to a minimum, no child processes are spawned, everything remains non-blocking thanks to _libuv_ and Promises/A+ are supported.

-Under the hood you'll find the blazingly fast [libvips](https://github.com/jcupitt/libvips) image processing library, originally created in 1989 at Birkbeck College and currently maintained by the University of Southampton.
+This module supports reading and writing JPEG, PNG and WebP images to and from Streams, Buffer objects and the filesystem. It also supports reading images of many other types from the filesystem via libmagick++ or libgraphicsmagick++ if present.

-Performance is 4x-8x faster than ImageMagick and 2x-4x faster than GraphicsMagick, based mainly on the number of CPU cores available.
+When generating JPEG output all metadata is removed and Huffman tables optimised without having to use separate command line tools like [jpegoptim](https://github.com/tjko/jpegoptim) and [jpegtran](http://jpegclub.org/jpegtran/).

-## Prerequisites
+Anyone who has used the Node.js bindings for [GraphicsMagick](https://github.com/aheckmann/gm) will find the API similarly fluent.

-* Node.js v0.8+
-* node-gyp
-* [libvips](https://github.com/jcupitt/libvips) v7.37+
+This module is powered by the blazingly fast [libvips](https://github.com/jcupitt/libvips) image processing library, originally created in 1989 at Birkbeck College and currently maintained by [John Cupitt](https://github.com/jcupitt).

-For the sharpest results, please compile libvips from source.
-
-If you prefer to run a stable, package-managed environment such as Ubuntu 12.04 LTS, [v0.0.3](https://github.com/lovell/sharp/tree/v0.0.3) will work with the libvips-dev package.
-
-## Install
+## Installation

 	npm install sharp

-## Usage
+### Prerequisites

-	var sharp = require("sharp");
+* Node.js v0.10+
+* [libvips](https://github.com/jcupitt/libvips) v7.38.5+

-### crop(input, output, width, height, callback)
+_libvips_ can take advantage of [liborc](http://code.entropywave.com/orc/) if present. Warning: versions of _liborc_ prior to 0.4.19 suffer [memory leaks](https://github.com/lovell/sharp/issues/21#issuecomment-42367306) and version 0.4.19 suffers [buffer overflows](https://github.com/lovell/sharp/issues/21#issuecomment-44813498).

-Scale and crop to `width` x `height` calling `callback` when complete.
+### Install libvips on Mac OS
+
+	brew install homebrew/science/vips --with-webp --with-graphicsmagick
+
+A missing or incorrectly configured _Xcode Command Line Tools_ installation [can lead](https://github.com/lovell/sharp/issues/80) to a `library not found for -ljpeg` error. If so, please try:
+
+	xcode-select --install
+
+The _gettext_ dependency of _libvips_ [can lead](https://github.com/lovell/sharp/issues/9) to a `library not found for -lintl` error. If so, please try:
+
+	brew link gettext --force
+
+### Install libvips on Ubuntu Linux
+
+#### Ubuntu 14.x
+
+	sudo apt-get install libvips-dev
+
+#### Ubuntu 13.x
+
+Compiling from source is recommended:
+
+	sudo apt-get install automake build-essential git gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-turbo8-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libxml2-dev swig
+	git clone https://github.com/jcupitt/libvips.git
+	cd libvips
+	git checkout 7.38
+	./bootstrap.sh
+	./configure --enable-debug=no --enable-cxx=yes --without-python --without-orc --without-fftw
+	make
+	sudo make install
+	sudo ldconfig
+
+#### Ubuntu 12.x
+
+Requires `libtiff4-dev` instead of `libtiff5-dev` and has [a bug](https://bugs.launchpad.net/ubuntu/+source/libwebp/+bug/1108731) in the libwebp package. Work around these problems by running these commands first:
+
+	sudo add-apt-repository ppa:lyrasis/precise-backports
+	sudo apt-get update
+	sudo apt-get install libtiff4-dev
+
+Then follow Ubuntu 13.x instructions.
+
+### Install libvips on Heroku
+
+[Alessandro Tagliapietra](https://github.com/alex88) maintains an [Heroku buildpack for libvips](https://github.com/alex88/heroku-buildpack-vips) and its dependencies.
+
+## Usage examples

 ```javascript
-sharp.crop("input.jpg", "output.jpg", 300, 200, function(err) {
+var sharp = require('sharp');
+```
+
+```javascript
+sharp('input.jpg').resize(300, 200).toFile('output.jpg', function(err) {
  if (err) {
    throw err;
  }
@@ -48,105 +95,325 @@ sharp.crop("input.jpg", "output.jpg", 300, 200, function(err) {
 ```

 ```javascript
-sharp.crop("input.jpg", sharp.buffer.jpeg, 300, 200, function(err, buffer) {
-  if (err) {
-    throw err;
-  }
-  // buffer contains JPEG image data
+var transformer = sharp().resize(300, 200).crop(sharp.gravity.north);
+readableStream.pipe(transformer).pipe(writableStream);
+// Read image data from readableStream, resize and write image data to writableStream
+```
+
+```javascript
+var image = sharp(inputJpg);
+image.metadata(function(err, metadata) {
+  image.resize(metadata.width / 2).webp().toBuffer(function(err, outputBuffer, info) {
+    // outputBuffer contains a WebP image half the width and height of the original JPEG
+  });
 });
 ```

 ```javascript
-sharp.crop("input.jpg", sharp.buffer.png, 300, 200, function(err, buffer) {
-  if (err) {
-    throw err;
-  }
-  // buffer contains PNG image data (converted from JPEG)
-});
+var pipeline = sharp()
+  .rotate()
+  .resize(null, 200)
+  .progressive()
+  .toBuffer(function(err, outputBuffer, info) {
+    if (err) {
+      throw err;
+    }
+    // outputBuffer contains 200px high progressive JPEG image data,
+    // auto-rotated using EXIF Orientation tag
+    // info.width and info.height contain the dimensions of the resized image
+  });
+readableStream.pipe(pipeline);
 ```

-### embedWhite(input, output, width, height, callback)
-
-Scale and embed to `width` x `height` using a white canvas calling `callback` when complete.
+```javascript
+sharp('input.png')
+  .rotate(180)
+  .resize(300)
+  .sharpen()
+  .quality(90)
+  .webp()
+  .toBuffer()
+  .then(function(outputBuffer) {
+    // outputBuffer contains 300px wide, upside down, sharpened,
+    // 90% quality WebP image data
+  });
+```

 ```javascript
-sharp.embedWhite("input.jpg", "output.jpg", 200, 300, function(err) {
+http.createServer(function(request, response) {
+  response.writeHead(200, {'Content-Type': 'image/webp'});
+  sharp('input.jpg').rotate().resize(200).webp().pipe(response);
+}).listen(8000);
+// Create HTTP server that always returns auto-rotated 'input.jpg',
+// resized to 200 pixels wide, in WebP format
+```
+
+```javascript
+sharp(inputBuffer)
+  .resize(200, 300)
+  .interpolateWith(sharp.interpolator.nohalo)
+  .embedWhite()
+  .toFile('output.tiff')
+  .then(function() {
+    // output.tiff is a 200 pixels wide and 300 pixels high image
+    // containing a bicubic scaled version, embedded on a white canvas,
+    // of the image data in inputBuffer
+  });
+```
+
+```javascript
+sharp('input.gif').resize(200, 300).embedBlack().webp().toBuffer(function(err, outputBuffer) {
  if (err) {
    throw err;
  }
-  // output.jpg is a 200 pixels wide and 300 pixels high image
-  // containing a scaled version of input.png embedded on a white canvas
+  // outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
+  // containing a scaled version, embedded on a black canvas, of input.gif
 });
 ```

 ```javascript
-sharp.embedWhite("input.jpg", sharp.buffer.jpeg, 200, 300, function(err, buffer) {
-  if (err) {
-    throw err;
-  }
-  // buffer contains JPEG image data
+sharp(inputBuffer).resize(200, 200).max().jpeg().toBuffer().then(function(outputBuffer) {
+  // outputBuffer contains JPEG image data no wider than 200 pixels and no higher
+  // than 200 pixels regardless of the inputBuffer image dimensions
 });
 ```

-### embedBlack(input, output, width, height, callback)
+## API

-Scale and embed to `width` x `height` using a black canvas calling `callback` when complete.
+### Input methods
+
+#### sharp([input])
+
+Constructor to which further methods are chained. `input`, if present, can be one of:
+
+* Buffer containing JPEG, PNG or WebP image data, or
+* String containing the filename of an image, with most major formats supported.
+
+The object returned implements the [stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
+
+JPEG, PNG or WebP format image data can be streamed into the object when `input` is not provided.
+
+JPEG, PNG or WebP format image data can be streamed out from this object.
+
+#### metadata([callback])
+
+Fast access to image metadata without decoding any compressed image data.
+
+`callback`, if present, gets the arguments `(err, metadata)` where `metadata` has the attributes:
+
+* `format`: Name of decoder to be used to decompress image data e.g. `jpeg`, `png`, `webp` (for file-based input additionally `tiff` and `magick`)
+* `width`: Number of pixels wide
+* `height`: Number of pixels high
+* `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `scrgb`, `cmyk`, `lab`, `xyz`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L502)
+* `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+* `orientation`: Number value of the EXIF Orientation header, if present
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+#### sequentialRead()
+
+An advanced setting that switches the libvips access method to `VIPS_ACCESS_SEQUENTIAL`. This will reduce memory usage and can improve performance on some systems.
+
+### Image transformation options
+
+#### resize(width, [height])
+
+Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
+
+`width` is the Number of pixels wide the resultant image should be. Use `null` or `undefined` to auto-scale the width to match the height.
+
+`height` is the Number of pixels high the resultant image should be. Use `null` or `undefined` to auto-scale the height to match the width.
+
+#### crop([gravity])
+
+Crop the resized image to the exact size specified, the default behaviour.
+
+`gravity`, if present, is an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
+
+Possible values are `north`, `east`, `south`, `west`, `center` and `centre`. The default gravity is `center`/`centre`.
+
+#### max()
+
+Preserving aspect ratio, resize the image to the maximum width or height specified.
+
+Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
+
+#### embedWhite()
+
+Embed the resized image on a white background of the exact size specified.
+
+#### embedBlack()
+
+Embed the resized image on a black background of the exact size specified.
+
+#### rotate([angle])
+
+Rotate the output image by either an explicit angle or auto-orient based on the EXIF `Orientation` tag.
+
+`angle`, if present, is a Number with a value of `0`, `90`, `180` or `270`.
+
+Use this method without `angle` to determine the angle from EXIF data. Mirroring is currently unsupported.
+
+#### withoutEnlargement()
+
+Do not enlarge the output image if the input image width *or* height are already less than the required dimensions.
+
+This is equivalent to GraphicsMagick's `>` geometry option: "change the dimensions of the image only if its width or height exceeds the geometry specification".
+
+#### sharpen()
+
+Perform a mild sharpen of the resultant image. This typically reduces performance by 30%.
+
+#### interpolateWith(interpolator)
+
+Use the given interpolator for image resizing, where `interpolator` is an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.bicubic`.
+
+Possible interpolators, in order of performance, are:
+
+* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), the default (and fastest) interpolation.
+* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation), which typically reduces performance by 5%.
+* `vertexSplitQuadraticBasisSpline`: Use [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48), which prevents "staircasing" when enlarging and typically reduces performance by 5%.
+* `locallyBoundedBicubic`: Use [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100), which prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" and typically reduces performance by a factor of 2.
+* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance and typically reduces performance by a factor of 3.
+
+### Output options
+
+#### progressive()
+
+Use progressive (interlace) scan for JPEG and PNG output. This typically reduces compression performance by 30% but results in an image that can be rendered sooner when decompressed.
+
+#### quality(quality)
+
+The output quality to use for lossy JPEG, WebP and TIFF output formats. The default quality is `80`.
+
+`quality` is a Number between 1 and 100.
+
+#### compressionLevel(compressionLevel)
+
+An advanced setting for the _zlib_ compression level of the lossless PNG output format. The default level is `6`.
+
+`compressionLevel` is a Number between -1 and 9.
+
+#### jpeg()
+
+Use JPEG format for the output image.
+
+#### png()
+
+Use PNG format for the output image.
+
+#### webp()
+
+Use WebP format for the output image.
+
+### Output methods
+
+#### toFile(filename, [callback])
+
+`filename` is a String containing the filename to write the image data to. The format is inferred from the extension, with JPEG, PNG, WebP and TIFF supported.
+
+`callback`, if present, is called with two arguments `(err, info)` where:
+
+* `err` contains an error message, if any
+* `info` contains the final resized image dimensions in its `width` and `height` properties
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+#### toBuffer([callback])
+
+Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG and WebP are supported.
+
+`callback`, if present, gets three arguments `(err, buffer, info)` where:
+
+* `err` is an error message, if any
+* `buffer` is the resultant image data
+* `info` contains the final resized image dimensions in its `width` and `height` properties
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+### Utility methods
+
+#### sharp.cache([memory], [items])
+
+If `memory` or `items` are provided, set the limits of _libvips'_ operation cache.
+
+* `memory` is the maximum memory in MB to use for this cache, with a default value of 100
+* `items` is the maximum number of operations to cache, with a default value of 500
+
+This method always returns cache statistics, useful for determining how much working memory is required for a particular task.

 ```javascript
-sharp.embedBlack("input.png", "output.png", 200, 300, function(err) {
-  if (err) {
-    throw err;
-  }
-  // output.png is a 200 pixels wide and 300 pixels high image
-  // containing a scaled version of input.png embedded on a black canvas
-});
+var stats = sharp.cache(); // { current: 75, high: 99, memory: 100, items: 500 }
+sharp.cache(200); // { current: 75, high: 99, memory: 200, items: 500 }
+sharp.cache(50, 200); // { current: 49, high: 99, memory: 50, items: 200}
 ```

-### Parameters common to all methods
+#### sharp.counters()

-#### input
+Provides access to internal task counters.

-String containing the filename to read from.
+* `queue` is the number of tasks this module has queued waiting for _libuv_ to provide a worker thread from its pool.
+* `process` is the number of resize tasks currently being processed.

-#### output
-
-One of:
-* String containing the filename to write to.
-* `sharp.buffer.jpeg` to pass a Buffer containing JPEG image data to `callback`.
-* `sharp.buffer.png` to pass a Buffer containing PNG image data to `callback`.
+```javascript
+var counters = sharp.counters(); // { queue: 2, process: 4 }
+```

 ## Testing

+[![Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+
 	npm test

+Running the tests requires both ImageMagick and GraphicsMagick plus one of either libmagick++-dev or libgraphicsmagick++.
+
+	brew install imagemagick
+	brew install graphicsmagick
+
+	sudo apt-get install imagemagick graphicsmagick libmagick++-dev
+
 ## Performance

-Test environment:
+### Test environment

-* AMD Athlon 4 core 3.3GHz 512KB L2 CPU 1333 DDR3
-* libvips 7.37
-* libjpeg-turbo8 1.3.0
-* libpng 1.6.6
-* zlib1g 1.2.7
+* Intel Xeon [L5520](http://ark.intel.com/products/40201/Intel-Xeon-Processor-L5520-8M-Cache-2_26-GHz-5_86-GTs-Intel-QPI) 2.27GHz 8MB cache
+* Ubuntu 13.10
+* libvips 7.38.5

-#### JPEG
+### The contenders

-* imagemagick x 5.53 ops/sec ±0.55% (31 runs sampled)
-* gm x 10.86 ops/sec ±0.43% (56 runs sampled)
-* epeg x 28.07 ops/sec ±0.07% (70 runs sampled)
-* sharp-file x 31.60 ops/sec ±8.80% (80 runs sampled)
-* sharp-buffer x 34.04 ops/sec ±0.36% (82 runs sampled)
+* [imagemagick-native](https://github.com/mash/node-imagemagick-native) - Supports Buffers only and blocks main V8 thread whilst processing.
+* [imagemagick](https://github.com/rsms/node-imagemagick) - Supports filesystem only and "has been unmaintained for a long time".
+* [gm](https://github.com/aheckmann/gm) - Fully featured wrapper around GraphicsMagick.
+* sharp - Caching within libvips disabled to ensure a fair comparison.

-#### PNG
+### The task

-* imagemagick x 4.65 ops/sec ±0.37% (27 runs sampled)
-* gm x 21.65 ops/sec ±0.18% (56 runs sampled)
-* sharp-file x 39.47 ops/sec ±6.78% (68 runs sampled)
-* sharp-buffer x 42.87 ops/sec ±0.19% (71 runs sampled)
+Decompress a 2725x2225 JPEG image, resize and crop to 720x480, then compress to JPEG.
+
+### Results
+
+| Module                | Input  | Output | Ops/sec | Speed-up |
+| :-------------------- | :----- | :----- | ------: | -------: |
+| imagemagick-native    | buffer | buffer |    0.97 |        1 |
+| imagemagick           | file   | file   |    2.49 |      2.6 |
+| gm                    | buffer | file   |    3.72 |      3.8 |
+| gm                    | buffer | buffer |    3.80 |      3.9 |
+| gm                    | file   | file   |    3.67 |      3.8 |
+| gm                    | file   | buffer |    3.67 |      3.8 |
+| sharp                 | buffer | file   |   13.62 |     14.0 |
+| sharp                 | buffer | buffer |   12.43 |     12.8 |
+| sharp                 | file   | file   |   13.02 |     13.4 |
+| sharp                 | file   | buffer |   11.15 |     11.5 |
+| sharp +sharpen        | file   | buffer |   10.26 |     10.6 |
+| sharp +progressive    | file   | buffer |    9.44 |      9.7 |
+| sharp +sequentialRead | file   | buffer |   11.94 |     12.3 |
+
+You can expect much greater performance with caching enabled (default) and using 16+ core machines.

 ## Licence

-Copyright 2013, 2014 Lovell Fuller
+Copyright 2013, 2014 Lovell Fuller, Pierre Inglebert, Jonathan Ong and Chanon Sajjamanochai

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
--- a/binding.gyp
+++ b/binding.gyp
@@ -2,16 +2,22 @@
  'targets': [{
    'target_name': 'sharp',
    'sources': ['src/sharp.cc'],
+    'variables': {
+      'PKG_CONFIG_PATH': '<!(which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR || true):$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig'
+    },
    'libraries': [
-      '<!@(PKG_CONFIG_PATH="/usr/local/lib/pkgconfig" pkg-config --libs vips)',
-      '<!@(PKG_CONFIG_PATH="/usr/lib/pkgconfig" pkg-config --libs vips)'
+      '<!(PKG_CONFIG_PATH="<(PKG_CONFIG_PATH)" pkg-config --libs vips)'
    ],
    'include_dirs': [
-      '/usr/include/glib-2.0',
-      '/usr/lib/glib-2.0/include',
-      '/usr/lib/x86_64-linux-gnu/glib-2.0/include'
+      '<!(PKG_CONFIG_PATH="<(PKG_CONFIG_PATH)" pkg-config --cflags vips glib-2.0)',
+      '<!(node -e "require(\'nan\')")'
    ],
-    'cflags': ['-fexceptions'],
-    'cflags_cc': ['-fexceptions']
+    'cflags': ['-fexceptions', '-Wall', '-O3'],
+    'cflags_cc': ['-std=c++0x', '-fexceptions', '-Wall', '-O3'],
+    'xcode_settings': {
+      'OTHER_CFLAGS': ['-std=c++11', '-stdlib=libc++', '-fexceptions', '-Wall', '-O3'],
+      'OTHER_CPLUSPLUSFLAGS': ['-std=c++11', '-stdlib=libc++', '-fexceptions', '-Wall', '-O3'],
+      'MACOSX_DEPLOYMENT_TARGET': '10.7'
+    }
  }]
 }
--- a/index.js
+++ b/index.js
@@ -1,18 +1,414 @@
-var sharp = require("./build/Release/sharp");
-
-module.exports.buffer = {
-  jpeg: "__jpeg",
-  png: "__png"
-};
-
-module.exports.crop = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "c", callback);
-};
-
-module.exports.embedWhite = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "w", callback);
-};
-
-module.exports.embedBlack = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "b", callback);
-};
+/*jslint node: true */
+'use strict';
+
+var util = require('util');
+var stream = require('stream');
+var Promise = require('bluebird');
+var sharp = require('./build/Release/sharp');
+
+var Sharp = function(input) {
+  if (!(this instanceof Sharp)) {
+    return new Sharp(input);
+  }
+  stream.Duplex.call(this);
+  this.options = {
+    width: -1,
+    height: -1,
+    canvas: 'c',
+    gravity: 0,
+    angle: 0,
+    withoutEnlargement: false,
+    sharpen: false,
+    interpolator: 'bilinear',
+    progressive: false,
+    sequentialRead: false,
+    quality: 80,
+    compressionLevel: 6,
+    streamIn: false,
+    streamOut: false,
+    output: '__input'
+  };
+  if (typeof input === 'string') {
+    // input=file
+    this.options.fileIn = input;
+  } else if (typeof input === 'object' && input instanceof Buffer) {
+    // input=buffer
+    if (input.length > 0) {
+      this.options.bufferIn = input;
+    } else {
+      throw new Error('Buffer is empty');
+    }
+  } else {
+    // input=stream
+    this.options.streamIn = true;
+  }
+  return this;
+};
+module.exports = Sharp;
+util.inherits(Sharp, stream.Duplex);
+
+/*
+  Handle incoming chunk on Writable Stream
+*/
+Sharp.prototype._write = function(chunk, encoding, callback) {
+  if (this.options.streamIn) {
+    if (typeof chunk === 'object' || chunk instanceof Buffer) {
+      if (typeof this.options.bufferIn === 'undefined') {
+        // Create new Buffer
+        this.options.bufferIn = new Buffer(chunk.length);
+        chunk.copy(this.options.bufferIn);
+      } else {
+        // Append to existing Buffer
+        this.options.bufferIn = Buffer.concat(
+          [this.options.bufferIn, chunk],
+          this.options.bufferIn.length + chunk.length
+        );
+      }
+      callback();
+    } else {
+      callback(new Error('Non-Buffer data on Writable Stream'));
+    }
+  } else {
+    callback(new Error('Unexpected data on Writable Stream'));
+  }
+};
+
+// Crop this part of the resized image (Center/Centre, North, East, South, West)
+module.exports.gravity = {'center': 0, 'centre': 0, 'north': 1, 'east': 2, 'south': 3, 'west': 4};
+
+Sharp.prototype.crop = function(gravity) {
+  this.options.canvas = 'c';
+  if (typeof gravity !== 'undefined') {
+    // Is this a supported gravity?
+    if (!Number.isNaN(gravity) && gravity >= 0 && gravity <= 4) {
+      this.options.gravity = gravity;
+    } else {
+      throw new Error('Unsupported crop gravity ' + gravity);
+    }
+  }
+  return this;
+};
+
+Sharp.prototype.embedWhite = function() {
+  this.options.canvas = 'w';
+  return this;
+};
+
+Sharp.prototype.embedBlack = function() {
+  this.options.canvas = 'b';
+  return this;
+};
+
+Sharp.prototype.max = function() {
+  this.options.canvas = 'm';
+  return this;
+};
+
+/*
+  Rotate output image by 0, 90, 180 or 270 degrees
+  Auto-rotation based on the EXIF Orientation tag is represented by an angle of -1
+*/
+Sharp.prototype.rotate = function(angle) {
+  if (typeof angle === 'undefined') {
+    this.options.angle = -1;
+  } else if (!Number.isNaN(angle) && [0, 90, 180, 270].indexOf(angle) !== -1) {
+    this.options.angle = angle;
+  } else {
+    throw new Error('Unsupported angle (0, 90, 180, 270) ' + angle);
+  }
+  return this;
+};
+
+/*
+  Do not enlarge the output if the input width *or* height are already less than the required dimensions
+  This is equivalent to GraphicsMagick's ">" geometry option:
+    "change the dimensions of the image only if its width or height exceeds the geometry specification"
+*/
+Sharp.prototype.withoutEnlargement = function(withoutEnlargement) {
+  this.options.withoutEnlargement = (typeof withoutEnlargement === 'boolean') ? withoutEnlargement : true;
+  return this;
+};
+
+Sharp.prototype.sharpen = function(sharpen) {
+  this.options.sharpen = (typeof sharpen === 'boolean') ? sharpen : true;
+  return this;
+};
+
+/*
+  Set the interpolator to use for the affine transformation
+*/
+module.exports.interpolator = {
+  bilinear: 'bilinear',
+  bicubic: 'bicubic',
+  nohalo: 'nohalo',
+  locallyBoundedBicubic: 'lbb',
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+Sharp.prototype.interpolateWith = function(interpolator) {
+  this.options.interpolator = interpolator;
+  return this;
+};
+
+/*
+  Deprecated interpolation methods, to be removed in v0.7.0
+*/
+Sharp.prototype.bilinearInterpolation = util.deprecate(function() {
+  return this.interpolateWith(module.exports.interpolator.bilinear);
+}, 'bilinearInterpolation() is deprecated, use interpolateWith(sharp.interpolator.bilinear) instead');
+Sharp.prototype.bicubicInterpolation = util.deprecate(function() {
+  return this.interpolateWith(module.exports.interpolator.bicubic);
+}, 'bicubicInterpolation() is deprecated, use interpolateWith(sharp.interpolator.bicubic) instead');
+Sharp.prototype.nohaloInterpolation = util.deprecate(function() {
+  return this.interpolateWith(module.exports.interpolator.nohalo);
+}, 'nohaloInterpolation() is deprecated, use interpolateWith(sharp.interpolator.nohalo) instead');
+
+Sharp.prototype.progressive = function(progressive) {
+  this.options.progressive = (typeof progressive === 'boolean') ? progressive : true;
+  return this;
+};
+
+Sharp.prototype.sequentialRead = function(sequentialRead) {
+  this.options.sequentialRead = (typeof sequentialRead === 'boolean') ? sequentialRead : true;
+  return this;
+};
+
+Sharp.prototype.quality = function(quality) {
+  if (!Number.isNaN(quality) && quality >= 1 && quality <= 100) {
+    this.options.quality = quality;
+  } else {
+    throw new Error('Invalid quality (1 to 100) ' + quality);
+  }
+  return this;
+};
+
+Sharp.prototype.compressionLevel = function(compressionLevel) {
+  if (!Number.isNaN(compressionLevel) && compressionLevel >= -1 && compressionLevel <= 9) {
+    this.options.compressionLevel = compressionLevel;
+  } else {
+    throw new Error('Invalid compressionLevel (-1 to 9) ' + compressionLevel);
+  }
+  return this;
+};
+
+Sharp.prototype.resize = function(width, height) {
+  if (!width) {
+    this.options.width = -1;
+  } else {
+    if (!Number.isNaN(width)) {
+      this.options.width = width;
+    } else {
+      throw new Error('Invalid width ' + width);
+    }
+  }
+  if (!height) {
+    this.options.height = -1;
+  } else {
+    if (!Number.isNaN(height)) {
+      this.options.height = height;
+    } else {
+      throw new Error('Invalid height ' + height);
+    }
+  }
+  return this;
+};
+
+/*
+  Write output image data to a file
+*/
+Sharp.prototype.toFile = function(output, callback) {
+  if (!output || output.length === 0) {
+    var errOutputInvalid = new Error('Invalid output');
+    if (typeof callback === 'function') {
+      callback(errOutputInvalid);
+    } else {
+      return Promise.reject(errOutputInvalid);
+    }
+  } else {
+    if (this.options.fileIn === output) {
+      var errOutputIsInput = new Error('Cannot use same file for input and output');
+      if (typeof callback === 'function') {
+        callback(errOutputIsInput);
+      } else {
+        return Promise.reject(errOutputIsInput);
+      }
+    } else {
+      this.options.output = output;
+      return this._sharp(callback);
+    }
+  }
+  return this;
+};
+
+Sharp.prototype.toBuffer = function(callback) {
+  return this._sharp(callback);
+};
+
+Sharp.prototype.jpeg = function() {
+  this.options.output = '__jpeg';
+  if (arguments.length > 0) {
+    console.error('Use of the jpeg() method with a callback is deprecated in 0.6.x and will be removed in 0.7.x');
+    console.error('Please add toFile(), toBuffer() or Stream methods e.g. pipe() for JPEG output');
+    this._sharp(arguments);
+  }
+  return this;
+};
+
+Sharp.prototype.png = function() {
+  this.options.output = '__png';
+  if (arguments.length > 0) {
+    console.error('Use of the png() method with a callback is deprecated in 0.6.x and will be removed in 0.7.x');
+    console.error('Please add toFile(), toBuffer() or Stream methods e.g. pipe() for PNG output');
+    this._sharp(arguments);
+  }
+  return this;
+};
+
+Sharp.prototype.webp = function() {
+  this.options.output = '__webp';
+  if (arguments.length > 0) {
+    console.error('Use of the webp() method with a callback is deprecated in 0.6.x and will be removed in 0.7.x');
+    console.error('Please add toFile(), toBuffer() or Stream methods e.g. pipe() for WebP output');
+    this._sharp(arguments);
+  }
+  return this;
+};
+
+/*
+  Used by a Writable Stream to notify that it is ready for data
+*/
+Sharp.prototype._read = function() {
+  if (!this.options.streamOut) {
+    this.options.streamOut = true;
+    this._sharp();
+  }
+};
+
+/*
+  Invoke the C++ image processing pipeline
+  Supports callback, stream and promise variants
+*/
+Sharp.prototype._sharp = function(callback) {
+  var that = this;
+  if (typeof callback === 'function') {
+    // output=file/buffer
+    if (this.options.streamIn) {
+      // output=file/buffer, input=stream
+      this.on('finish', function() {
+        sharp.resize(that.options, callback);
+      });
+    } else {
+      // output=file/buffer, input=file/buffer
+      sharp.resize(this.options, callback);
+    }
+    return this;
+  } else if (this.options.streamOut) {
+    // output=stream
+    if (this.options.streamIn) {
+      // output=stream, input=stream
+      this.on('finish', function() {
+        sharp.resize(that.options, function(err, data) {
+          if (err) throw err;
+          that.push(data);
+          that.push(null);
+        });
+      });
+    } else {
+      // output=stream, input=file/buffer
+      sharp.resize(this.options, function(err, data) {
+        if (err) throw err;
+        that.push(data);
+        that.push(null);
+      });
+    }
+    return this;
+  } else {
+    // output=promise
+    if (this.options.streamIn) {
+      // output=promise, input=stream
+      return new Promise(function(resolve, reject) {
+        that.on('finish', function() {
+          sharp.resize(that.options, function(err, data) {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(data);
+            }
+          });
+        });
+      });
+    } else {
+      // output=promise, input=file/buffer
+      return new Promise(function(resolve, reject) {
+        sharp.resize(that.options, function(err, data) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(data);
+          }
+        });
+      });
+    }
+  }
+};
+
+/*
+  Reads the image header and returns metadata
+  Supports callback, stream and promise variants
+*/
+Sharp.prototype.metadata = function(callback) {
+  var that = this;
+  if (typeof callback === 'function') {
+    if (this.options.streamIn) {
+      this.on('finish', function() {
+        sharp.metadata(that.options, callback);
+      });
+    } else {
+      sharp.metadata(this.options, callback);
+    }
+    return this;
+  } else {
+    if (this.options.streamIn) {
+      return new Promise(function(resolve, reject) {
+        that.on('finish', function() {
+          sharp.metadata(that.options, function(err, data) {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(data);
+            }
+          });
+        });
+      });
+    } else {
+      return new Promise(function(resolve, reject) {
+        sharp.metadata(that.options, function(err, data) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(data);
+          }
+        });
+      });
+    }
+  }
+};
+
+/*
+  Get and set cache memory and item limits
+*/
+module.exports.cache = function(memory, items) {
+  if (Number.isNaN(memory)) {
+    memory = null;
+  }
+  if (Number.isNaN(items)) {
+    items = null;
+  }
+  return sharp.cache(memory, items);
+};
+
+/*
+  Get internal counters
+*/
+module.exports.counters = function() {
+  return sharp.counters();
+};
--- a/package.json
+++ b/package.json
@@ -1,10 +1,15 @@
 {
  "name": "sharp",
-  "version": "0.0.8",
-  "author": "Lovell Fuller",
-  "description": "High performance module to resize JPEG and PNG images using the libvips image processing library",
+  "version": "0.6.1",
+  "author": "Lovell Fuller <npm@lovell.info>",
+  "contributors": [
+    "Pierre Inglebert <pierre.inglebert@gmail.com>",
+    "Jonathan Ong <jonathanrichardong@gmail.com>",
+    "Chanon Sajjamanochai <chanon.s@gmail.com>"
+  ],
+  "description": "High performance Node.js module to resize JPEG, PNG and WebP images using the libvips library",
  "scripts": {
-    "test": "node tests/perf.js"
+    "test": "node tests/unit && node tests/perf"
  },
  "main": "index.js",
  "repository": {
@@ -14,24 +19,33 @@
  "keywords": [
    "jpeg",
    "png",
+    "webp",
+    "tiff",
+    "gif",
    "resize",
    "thumbnail",
    "sharpen",
    "crop",
    "embed",
    "libvips",
+    "vips",
    "fast",
-    "buffer"
+    "buffer",
+    "stream"
  ],
+  "dependencies": {
+    "nan": "^1.3.0",
+    "bluebird": "^2.3.1"
+  },
  "devDependencies": {
-    "imagemagick": "*",
-    "gm": "*",
-    "epeg": "*",
-    "async": "*",
-    "benchmark": "*"
+    "imagemagick": "^0.1.3",
+    "imagemagick-native": "^1.2.2",
+    "gm": "^1.16.0",
+    "async": "^0.9.0",
+    "benchmark": "^1.0.0"
  },
  "license": "Apache 2.0",
  "engines": {
-    "node": ">=0.8"
+    "node": ">=0.10"
  }
-}
+}
--- a/src/sharp.cc
+++ b/src/sharp.cc
@@ -1,227 +1,777 @@
 #include <node.h>
+#include <node_buffer.h>
 #include <math.h>
 #include <string>
-#include <vector>
+#include <string.h>
+#include <tuple>
 #include <vips/vips.h>
-#include <node_buffer.h>
+
+#include "nan.h"

 using namespace v8;
 using namespace node;

-// Free VipsImage children when object goes out of scope
-// Thanks due to https://github.com/dosx/node-vips
-class ImageFreer {
-  public:
-    ImageFreer() {}
-    ~ImageFreer() {
-      for (uint16_t i = 0; i < v_.size(); i++) {
-        if (v_[i] != NULL) {
-          g_object_unref(v_[i]);
-        }
-      }
-      v_.clear();
-    }
-    void add(VipsImage* i) { v_.push_back(i); }
-  private:
-    std::vector<VipsImage*> v_;
-};
-
-struct ResizeBaton {
-  std::string src;
-  std::string dst;
+struct resize_baton {
+  std::string file_in;
+  void* buffer_in;
+  size_t buffer_in_len;
+  std::string output;
  void* buffer_out;
  size_t buffer_out_len;
-  int  cols;
-  int  rows;
+  int width;
+  int height;
  bool crop;
-  int  embed;
+  int gravity;
+  bool max;
+  VipsExtend extend;
+  bool sharpen;
+  std::string interpolator;
+  bool progressive;
+  bool without_enlargement;
+  VipsAccess access_method;
+  int quality;
+  int compressionLevel;
+  int angle;
  std::string err;
-  Persistent<Function> callback;

-  ResizeBaton() : buffer_out_len(0) {}
+  resize_baton():
+    buffer_in_len(0),
+    buffer_out_len(0),
+    crop(false),
+    gravity(0),
+    max(false),
+    sharpen(false),
+    progressive(false),
+    without_enlargement(false) {}
 };

-bool EndsWith(std::string const &str, std::string const &end) {
+typedef enum {
+  UNKNOWN,
+  JPEG,
+  PNG,
+  WEBP,
+  TIFF,
+  MAGICK
+} ImageType;
+
+unsigned char const MARKER_JPEG[] = {0xff, 0xd8};
+unsigned char const MARKER_PNG[] = {0x89, 0x50};
+unsigned char const MARKER_WEBP[] = {0x52, 0x49};
+
+// How many tasks are in the queue?
+volatile int counter_queue = 0;
+// How many tasks are being processed?
+volatile int counter_process = 0;
+
+static bool ends_with(std::string const &str, std::string const &end) {
  return str.length() >= end.length() && 0 == str.compare(str.length() - end.length(), end.length(), end);
 }

-void ResizeAsync(uv_work_t *work) {
-  ResizeBaton* baton = static_cast<ResizeBaton*>(work->data);
+static bool is_jpeg(std::string const &str) {
+  return ends_with(str, ".jpg") || ends_with(str, ".jpeg") || ends_with(str, ".JPG") || ends_with(str, ".JPEG");
+}

-  VipsImage *in = vips_image_new_mode((baton->src).c_str(), "p");
-  if (EndsWith(baton->src, ".jpg") || EndsWith(baton->src, ".jpeg"))  {
-    vips_jpegload((baton->src).c_str(), &in, NULL);
-  } else if (EndsWith(baton->src, ".png")) {
-    vips_pngload((baton->src).c_str(), &in, NULL);
-  } else {
-    (baton->err).append("Unsupported input file type");
-    return;
-  }
-  if (in == NULL) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-  ImageFreer freer;
-  freer.add(in);
+static bool is_png(std::string const &str) {
+  return ends_with(str, ".png") || ends_with(str, ".PNG");
+}

-  VipsImage* img = in;
-  VipsImage* t[4];
+static bool is_webp(std::string const &str) {
+  return ends_with(str, ".webp") || ends_with(str, ".WEBP");
+}

-  if (im_open_local_array(img, t, 4, "temp", "p")) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
+static bool is_tiff(std::string const &str) {
+  return ends_with(str, ".tif") || ends_with(str, ".tiff") || ends_with(str, ".TIF") || ends_with(str, ".TIFF");
+}

-  double xfactor = static_cast<double>(img->Xsize) / std::max(baton->cols, 1);
-  double yfactor = static_cast<double>(img->Ysize) / std::max(baton->rows, 1);
-  double factor = baton->crop ? std::min(xfactor, yfactor) : std::max(xfactor, yfactor);
-  factor = std::max(factor, 1.0);
-  int shrink = floor(factor);
-  double residual = shrink / factor;
-
-  // Use im_shrink with the integral reduction
-  if (im_shrink(img, t[0], shrink, shrink)) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-
-  // Use im_affinei with the remaining float part using bilinear interpolation
-  if (im_affinei_all(t[0], t[1], vips_interpolate_bilinear_static(), residual, 0, 0, residual, 0, 0)) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-  img = t[1];
-
-  if (baton->crop) {
-    int width = std::min(img->Xsize, baton->cols);
-    int height = std::min(img->Ysize, baton->rows);
-    int left = (img->Xsize - width + 1) / 2;
-    int top = (img->Ysize - height + 1) / 2;
-    if (im_extract_area(img, t[2], left, top, width, height)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-      return;
-    }
-    img = t[2];
-  } else {
-    int left = (baton->cols - img->Xsize) / 2;
-    int top = (baton->rows - img->Ysize) / 2;
-    if (im_embed(img, t[2], baton->embed, left, top, baton->cols, baton->rows)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-      return;
-    }
-    img = t[2];
-  }
-
-  // Mild sharpen
-  INTMASK* sharpen = im_create_imaskv("sharpen", 3, 3,
-    -1, -1, -1,
-    -1, 32, -1,
-    -1, -1, -1);
-  sharpen->scale = 24;
-  if (im_conv(img, t[3], sharpen)) { 
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-    return;
-  }
-  img = t[3];
-
-  if (baton->dst == "__jpeg") {
-    // Write JPEG to buffer
-    if (vips_jpegsave_buffer(img, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", 80, "optimize_coding", TRUE, NULL)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-      return;
-    }
-  } else if (baton->dst == "__png") {
-    // Write PNG to buffer
-    if (vips_pngsave_buffer(img, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "compression", 6, "interlace", FALSE, NULL)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-      return;
-    }
-  } else if (EndsWith(baton->dst, ".jpg") || EndsWith(baton->dst, ".jpeg"))  {
-    // Write JPEG to file
-    if (vips_foreign_save(img, baton->dst.c_str(), "strip", TRUE, "Q", 80, "optimize_coding", TRUE, NULL)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-    }
-  } else if (EndsWith(baton->dst, ".png")) {
-    // Write PNG to file
-    if (vips_foreign_save(img, baton->dst.c_str(), "strip", TRUE, "compression", 6, "interlace", FALSE, NULL)) {
-      (baton->err).append(vips_error_buffer());
-      vips_error_clear();
-    }
-  } else {
-    (baton->err).append("Unsupported output file type");
-  }
+static void resize_error(resize_baton *baton, VipsImage *unref) {
+  (baton->err).append(vips_error_buffer());
+  vips_error_clear();
+  g_object_unref(unref);
  vips_thread_shutdown();
+  return;
 }

-void ResizeAsyncAfter(uv_work_t *work, int status) {
-  HandleScope scope;
+/*
+  Calculate the angle of rotation for the output image.
+  In order of priority:
+   1. Use explicitly requested angle (supports 90, 180, 270)
+   2. Use input image EXIF Orientation header (does not support mirroring)
+   3. Otherwise default to zero, i.e. no rotation
+*/
+static VipsAngle
+sharp_calc_rotation(int const angle, VipsImage const *input) {
+  VipsAngle rotate = VIPS_ANGLE_0;
+  if (angle == -1) {
+    const char *exif;
+    if (!vips_image_get_string(input, "exif-ifd0-Orientation", &exif)) {
+      if (exif[0] == 0x36) { // "6"
+        rotate = VIPS_ANGLE_90;
+      } else if (exif[0] == 0x33) { // "3"
+        rotate = VIPS_ANGLE_180;
+      } else if (exif[0] == 0x38) { // "8"
+        rotate = VIPS_ANGLE_270;
+      }
+    }
+  } else {
+    if (angle == 90) {
+      rotate = VIPS_ANGLE_90;
+    } else if (angle == 180) {
+      rotate = VIPS_ANGLE_180;
+    } else if (angle == 270) {
+      rotate = VIPS_ANGLE_270;
+    }
+  }
+  return rotate;
+}

-  ResizeBaton *baton = static_cast<ResizeBaton*>(work->data);
+/*
+  Calculate the (left, top) coordinates of the output image
+  within the input image, applying the given gravity.
+*/
+static std::tuple<int, int>
+sharp_calc_crop(int const inWidth, int const inHeight, int const outWidth, int const outHeight, int const gravity) {
+  int left = 0;
+  int top = 0;
+  switch (gravity) {
+    case 1: // North
+      left = (inWidth - outWidth + 1) / 2;
+      break;
+    case 2: // East
+      left = inWidth - outWidth;
+      top = (inHeight - outHeight + 1) / 2;
+      break;
+    case 3: // South
+      left = (inWidth - outWidth + 1) / 2;
+      top = inHeight - outHeight;
+      break;
+    case 4: // West
+      top = (inHeight - outHeight + 1) / 2;
+      break;
+    default: // Centre
+      left = (inWidth - outWidth + 1) / 2;
+      top = (inHeight - outHeight + 1) / 2;
+  }
+  return std::make_tuple(left, top);
+}

-  Local<Value> null = Local<Value>::New(Null());
-  Local<Value> argv[2] = {null, null};
-  if (!baton->err.empty()) {
-    // Error
-    argv[0] = String::New(baton->err.data(), baton->err.size());
-  } else if (baton->buffer_out_len > 0) {
-    // Buffer
-    Buffer *buffer = Buffer::New((const char*)(baton->buffer_out), baton->buffer_out_len);
-    argv[1] = Local<Object>::New(buffer->handle_);
-    vips_free(baton->buffer_out);
+/*
+  Initialise a VipsImage from a buffer. Supports JPEG, PNG and WebP.
+  Returns the ImageType detected, if any.
+*/
+static ImageType
+sharp_init_image_from_buffer(VipsImage **image, void *buffer, size_t const length, VipsAccess const access) {
+  ImageType imageType = UNKNOWN;
+  if (memcmp(MARKER_JPEG, buffer, 2) == 0) {
+    if (!vips_jpegload_buffer(buffer, length, image, "access", access, NULL)) {
+      imageType = JPEG;
+    }
+  } else if(memcmp(MARKER_PNG, buffer, 2) == 0) {
+    if (!vips_pngload_buffer(buffer, length, image, "access", access, NULL)) {
+      imageType = PNG;
+    }
+  } else if(memcmp(MARKER_WEBP, buffer, 2) == 0) {
+    if (!vips_webpload_buffer(buffer, length, image, "access", access, NULL)) {
+      imageType = WEBP;
+    }
+  }
+  return imageType;
+}
+
+/*
+  Initialise a VipsImage from a file.
+  Returns the ImageType detected, if any.
+*/
+static ImageType
+sharp_init_image_from_file(VipsImage **image, char const *file, VipsAccess const access) {
+  ImageType imageType = UNKNOWN;
+  if (vips_foreign_is_a("jpegload", file)) {
+    if (!vips_jpegload(file, image, "access", access, NULL)) {
+      imageType = JPEG;
+    }
+  } else if (vips_foreign_is_a("pngload", file)) {
+    if (!vips_pngload(file, image, "access", access, NULL)) {
+      imageType = PNG;
+    }
+  } else if (vips_foreign_is_a("webpload", file)) {
+    if (!vips_webpload(file, image, "access", access, NULL)) {
+      imageType = WEBP;
+    }
+  } else if (vips_foreign_is_a("tiffload", file)) {
+    if (!vips_tiffload(file, image, "access", access, NULL)) {
+      imageType = TIFF;
+    }
+  } else if(vips_foreign_is_a("magickload", file)) {
+    if (!vips_magickload(file, image, "access", access, NULL)) {
+      imageType = MAGICK;
+    }
+  }
+  return imageType;
+}
+
+// Metadata
+
+struct metadata_baton {
+  // Input
+  std::string file_in;
+  void* buffer_in;
+  size_t buffer_in_len;
+  // Output
+  std::string format;
+  int width;
+  int height;
+  std::string space;
+  int channels;
+  int orientation;
+  std::string err;
+
+  metadata_baton():
+    buffer_in_len(0),
+    orientation(0) {}
+};
+
+class MetadataWorker : public NanAsyncWorker {
+
+  public:
+    MetadataWorker(NanCallback *callback, metadata_baton *baton) : NanAsyncWorker(callback), baton(baton) {}
+    ~MetadataWorker() {}
+
+  void Execute() {
+    // Decrement queued task counter
+    g_atomic_int_dec_and_test(&counter_queue);
+
+    ImageType imageType = UNKNOWN;
+    VipsImage *image = vips_image_new();
+    if (baton->buffer_in_len > 1) {
+      // From buffer
+      imageType = sharp_init_image_from_buffer(&image, baton->buffer_in, baton->buffer_in_len, VIPS_ACCESS_RANDOM);
+      if (imageType == UNKNOWN) {
+        (baton->err).append("Input buffer contains unsupported image format");
+      }
+    } else {
+      // From file
+      imageType = sharp_init_image_from_file(&image, baton->file_in.c_str(), VIPS_ACCESS_RANDOM);
+      if (imageType == UNKNOWN) {
+        (baton->err).append("File is of an unsupported image format");
+      }
+    }
+    if (imageType != UNKNOWN) {
+      // Image type
+      switch (imageType) {
+        case JPEG: baton->format = "jpeg"; break;
+        case PNG: baton->format = "png"; break;
+        case WEBP: baton->format = "webp"; break;
+        case TIFF: baton->format = "tiff"; break;
+        case MAGICK: baton->format = "magick"; break;
+        case UNKNOWN: default: baton->format = "";
+      }
+      // VipsImage attributes
+      baton->width = image->Xsize;
+      baton->height = image->Ysize;
+      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image->Type);
+      baton->channels = image->Bands;
+      // EXIF Orientation
+      const char *exif;
+      if (!vips_image_get_string(image, "exif-ifd0-Orientation", &exif)) {
+        baton->orientation = atoi(&exif[0]);
+      }
+    }
+    // Clean up
+    g_object_unref(image);
+    vips_error_clear();
+    vips_thread_shutdown();
  }

-  baton->callback->Call(Context::GetCurrent()->Global(), 2, argv);
-  baton->callback.Dispose();
-  delete baton;
-  delete work;
+  void HandleOKCallback () {
+    NanScope();
+
+    Handle<Value> argv[2] = { NanNull(), NanNull() };
+    if (!baton->err.empty()) {
+      // Error
+      argv[0] = NanNew<String>(baton->err.data(), baton->err.size());
+    } else {
+      // Metadata Object
+      Local<Object> info = NanNew<Object>();
+      info->Set(NanNew<String>("format"), NanNew<String>(baton->format));
+      info->Set(NanNew<String>("width"), NanNew<Number>(baton->width));
+      info->Set(NanNew<String>("height"), NanNew<Number>(baton->height));
+      info->Set(NanNew<String>("space"), NanNew<String>(baton->space));
+      info->Set(NanNew<String>("channels"), NanNew<Number>(baton->channels));
+      if (baton->orientation > 0) {
+        info->Set(NanNew<String>("orientation"), NanNew<Number>(baton->orientation));
+      }
+      argv[1] = info;
+    }
+    delete baton;
+
+    // Return to JavaScript
+    callback->Call(2, argv);
+  }
+
+  private:
+    metadata_baton* baton;
+};
+
+/*
+  metadata(options, callback)
+*/
+NAN_METHOD(metadata) {
+  NanScope();
+
+  // V8 objects are converted to non-V8 types held in the baton struct
+  metadata_baton *baton = new metadata_baton;
+  Local<Object> options = args[0]->ToObject();
+
+  // Input filename
+  baton->file_in = *String::Utf8Value(options->Get(NanNew<String>("fileIn"))->ToString());
+  // Input Buffer object
+  if (options->Get(NanNew<String>("bufferIn"))->IsObject()) {
+    Local<Object> buffer = options->Get(NanNew<String>("bufferIn"))->ToObject();
+    baton->buffer_in_len = Buffer::Length(buffer);
+    baton->buffer_in = Buffer::Data(buffer);
+  }
+
+  // Join queue for worker thread
+  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
+  NanAsyncQueueWorker(new MetadataWorker(callback, baton));
+
+  // Increment queued task counter
+  g_atomic_int_inc(&counter_queue);
+
+  NanReturnUndefined();
 }

-Handle<Value> Resize(const Arguments& args) {
-  HandleScope scope;
-  
-  ResizeBaton *baton = new ResizeBaton;
-  baton->src = *String::Utf8Value(args[0]->ToString());
-  baton->dst = *String::Utf8Value(args[1]->ToString());
-  baton->cols = args[2]->Int32Value();
-  baton->rows = args[3]->Int32Value();
-  Local<String> canvas = args[4]->ToString();
-  if (canvas->Equals(String::NewSymbol("c"))) {
+// Resize
+
+class ResizeWorker : public NanAsyncWorker {
+  public:
+    ResizeWorker(NanCallback *callback, resize_baton *baton) : NanAsyncWorker(callback), baton(baton) {}
+    ~ResizeWorker() {}
+
+  void Execute() {
+    // Decrement queued task counter
+    g_atomic_int_dec_and_test(&counter_queue);
+    // Increment processing task counter
+    g_atomic_int_inc(&counter_process);
+
+    // Input
+    ImageType inputImageType = UNKNOWN;
+    VipsImage *in = vips_image_new();
+    if (baton->buffer_in_len > 1) {
+      // From buffer
+      inputImageType = sharp_init_image_from_buffer(&in, baton->buffer_in, baton->buffer_in_len, baton->access_method);
+      if (inputImageType == UNKNOWN) {
+        (baton->err).append("Input buffer contains unsupported image format");
+      }
+    } else {
+      // From file
+      inputImageType = sharp_init_image_from_file(&in, baton->file_in.c_str(), baton->access_method);
+      if (inputImageType == UNKNOWN) {
+        (baton->err).append("File is of an unsupported image format");
+      }
+    }
+    if (inputImageType == UNKNOWN) {
+      return resize_error(baton, in);
+    }
+
+    // Get input image width and height
+    int inputWidth = in->Xsize;
+    int inputHeight = in->Ysize;
+
+    // Calculate angle of rotation, to be carried out later
+    VipsAngle rotation = sharp_calc_rotation(baton->angle, in);
+    if (rotation == VIPS_ANGLE_90 || rotation == VIPS_ANGLE_270) {
+      // Swap input output width and height when rotating by 90 or 270 degrees
+      int swap = inputWidth;
+      inputWidth = inputHeight;
+      inputHeight = swap;
+    }
+
+    // Scaling calculations
+    double factor;
+    if (baton->width > 0 && baton->height > 0) {
+      // Fixed width and height
+      double xfactor = static_cast<double>(inputWidth) / static_cast<double>(baton->width);
+      double yfactor = static_cast<double>(inputHeight) / static_cast<double>(baton->height);
+      factor = baton->crop ? std::min(xfactor, yfactor) : std::max(xfactor, yfactor);
+      // if max is set, we need to compute the real size of the thumb image
+      if (baton->max) {
+        if (xfactor > yfactor) {
+          baton->height = round(static_cast<double>(inputHeight) / xfactor);
+        } else {
+          baton->width = round(static_cast<double>(inputWidth) / yfactor);
+        }
+      }
+    } else if (baton->width > 0) {
+      // Fixed width, auto height
+      factor = static_cast<double>(inputWidth) / static_cast<double>(baton->width);
+      baton->height = floor(static_cast<double>(inputHeight) / factor);
+    } else if (baton->height > 0) {
+      // Fixed height, auto width
+      factor = static_cast<double>(inputHeight) / static_cast<double>(baton->height);
+      baton->width = floor(static_cast<double>(inputWidth) / factor);
+    } else {
+      // Identity transform
+      factor = 1;
+      baton->width = inputWidth;
+      baton->height = inputHeight;
+    }
+    int shrink = floor(factor);
+    if (shrink < 1) {
+      shrink = 1;
+    }
+    double residual = static_cast<double>(shrink) / factor;
+
+    // Do not enlarge the output if the input width *or* height are already less than the required dimensions
+    if (baton->without_enlargement) {
+      if (inputWidth < baton->width || inputHeight < baton->height) {
+        factor = 1;
+        shrink = 1;
+        residual = 0;
+        baton->width = inputWidth;
+        baton->height = inputHeight;
+      }
+    }
+
+    // Try to use libjpeg shrink-on-load
+    int shrink_on_load = 1;
+    if (inputImageType == JPEG) {
+      if (shrink >= 8) {
+        factor = factor / 8;
+        shrink_on_load = 8;
+      } else if (shrink >= 4) {
+        factor = factor / 4;
+        shrink_on_load = 4;
+      } else if (shrink >= 2) {
+        factor = factor / 2;
+        shrink_on_load = 2;
+      }
+    }
+    VipsImage *shrunk_on_load = vips_image_new();
+    if (shrink_on_load > 1) {
+      // Recalculate integral shrink and double residual
+      factor = std::max(factor, 1.0);
+      shrink = floor(factor);
+      residual = static_cast<double>(shrink) / factor;
+      // Reload input using shrink-on-load
+      if (baton->buffer_in_len > 1) {
+        if (vips_jpegload_buffer(baton->buffer_in, baton->buffer_in_len, &shrunk_on_load, "shrink", shrink_on_load, NULL)) {
+          return resize_error(baton, in);
+        }
+      } else {
+        if (vips_jpegload((baton->file_in).c_str(), &shrunk_on_load, "shrink", shrink_on_load, NULL)) {
+          return resize_error(baton, in);
+        }
+      }
+    } else {
+      vips_copy(in, &shrunk_on_load, NULL);
+    }
+    g_object_unref(in);
+
+    VipsImage *shrunk = vips_image_new();
+    if (shrink > 1) {
+      // Use vips_shrink with the integral reduction
+      if (vips_shrink(shrunk_on_load, &shrunk, shrink, shrink, NULL)) {
+        return resize_error(baton, shrunk_on_load);
+      }
+      // Recalculate residual float based on dimensions of required vs shrunk images
+      double shrunkWidth = shrunk->Xsize;
+      double shrunkHeight = shrunk->Ysize;
+      if (rotation == VIPS_ANGLE_90 || rotation == VIPS_ANGLE_270) {
+        // Swap input output width and height when rotating by 90 or 270 degrees
+        int swap = shrunkWidth;
+        shrunkWidth = shrunkHeight;
+        shrunkHeight = swap;
+      }
+      double residualx = static_cast<double>(baton->width) / static_cast<double>(shrunkWidth);
+      double residualy = static_cast<double>(baton->height) / static_cast<double>(shrunkHeight);
+      if (baton->crop || baton->max) {
+        residual = std::max(residualx, residualy);
+      } else {
+        residual = std::min(residualx, residualy);
+      }
+    } else {
+      vips_copy(shrunk_on_load, &shrunk, NULL);
+    }
+    g_object_unref(shrunk_on_load);
+
+    // Use vips_affine with the remaining float part
+    VipsImage *affined = vips_image_new();
+    if (residual != 0) {
+      // Create interpolator - "bilinear" (default), "bicubic" or "nohalo"
+      VipsInterpolate *interpolator = vips_interpolate_new(baton->interpolator.c_str());
+      // Perform affine transformation
+      if (vips_affine(shrunk, &affined, residual, 0, 0, residual, "interpolate", interpolator, NULL)) {
+        g_object_unref(interpolator);
+        return resize_error(baton, shrunk);
+      }
+      g_object_unref(interpolator);
+    } else {
+      vips_copy(shrunk, &affined, NULL);
+    }
+    g_object_unref(shrunk);
+
+    // Rotate
+    VipsImage *rotated = vips_image_new();
+    if (rotation != VIPS_ANGLE_0) {
+      if (vips_rot(affined, &rotated, rotation, NULL)) {
+        return resize_error(baton, affined);
+      }
+    } else {
+      vips_copy(affined, &rotated, NULL);
+    }
+    g_object_unref(affined);
+
+    // Crop/embed
+    VipsImage *canvased = vips_image_new();
+    if (rotated->Xsize != baton->width || rotated->Ysize != baton->height) {
+      if (baton->crop || baton->max) {
+        // Crop/max
+        int left;
+        int top;
+        std::tie(left, top) = sharp_calc_crop(rotated->Xsize, rotated->Ysize, baton->width, baton->height, baton->gravity);
+        int width = std::min(rotated->Xsize, baton->width);
+        int height = std::min(rotated->Ysize, baton->height);
+        if (vips_extract_area(rotated, &canvased, left, top, width, height, NULL)) {
+          return resize_error(baton, rotated);
+        }
+      } else {
+        // Embed
+        int left = (baton->width - rotated->Xsize) / 2;
+        int top = (baton->height - rotated->Ysize) / 2;
+        if (vips_embed(rotated, &canvased, left, top, baton->width, baton->height, "extend", baton->extend, NULL)) {
+          return resize_error(baton, rotated);
+        }
+      }
+    } else {
+      vips_copy(rotated, &canvased, NULL);
+    }
+    g_object_unref(rotated);
+
+    // Mild sharpen
+    VipsImage *sharpened = vips_image_new();
+    if (baton->sharpen) {
+      VipsImage *sharpen = vips_image_new_matrixv(3, 3,
+        -1.0, -1.0, -1.0,
+        -1.0, 32.0, -1.0,
+        -1.0, -1.0, -1.0);
+      vips_image_set_double(sharpen, "scale", 24);
+      if (vips_conv(canvased, &sharpened, sharpen, NULL)) {
+        g_object_unref(sharpen);
+        return resize_error(baton, canvased);
+      }
+      g_object_unref(sharpen);
+    } else {
+      vips_copy(canvased, &sharpened, NULL);
+    }
+    g_object_unref(canvased);
+
+    // Always convert to sRGB colour space
+    VipsImage *colourspaced = vips_image_new();
+    vips_colourspace(sharpened, &colourspaced, VIPS_INTERPRETATION_sRGB, NULL);
+    g_object_unref(sharpened);
+
+    // Generate image tile cache when interlace output is required
+    VipsImage *cached = vips_image_new();
+    if (baton->progressive) {
+      if (vips_tilecache(colourspaced, &cached, "threaded", TRUE, "persistent", TRUE, "max_tiles", -1, NULL)) {
+        return resize_error(baton, colourspaced);
+      }
+    } else {
+      vips_copy(colourspaced, &cached, NULL);
+    }
+    g_object_unref(colourspaced);
+
+    // Output
+    VipsImage *output = cached;
+    if (baton->output == "__jpeg" || (baton->output == "__input" && inputImageType == JPEG)) {
+      // Write JPEG to buffer
+      if (vips_jpegsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
+        return resize_error(baton, output);
+      }
+    } else if (baton->output == "__png" || (baton->output == "__input" && inputImageType == PNG)) {
+      // Write PNG to buffer
+      if (vips_pngsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
+        return resize_error(baton, output);
+      }
+    } else if (baton->output == "__webp" || (baton->output == "__input" && inputImageType == WEBP)) {
+      // Write WEBP to buffer
+      if (vips_webpsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", baton->quality, NULL)) {
+        return resize_error(baton, output);
+      }
+    } else if (is_jpeg(baton->output))  {
+      // Write JPEG to file
+      if (vips_jpegsave(output, baton->output.c_str(), "strip", TRUE, "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
+        return resize_error(baton, output);
+      }
+    } else if (is_png(baton->output)) {
+      // Write PNG to file
+      if (vips_pngsave(output, baton->output.c_str(), "strip", TRUE, "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
+        return resize_error(baton, output);
+      }
+    } else if (is_webp(baton->output)) {
+      // Write WEBP to file
+      if (vips_webpsave(output, baton->output.c_str(), "strip", TRUE, "Q", baton->quality, NULL)) {
+        return resize_error(baton, output);
+      }
+    } else if (is_tiff(baton->output)) {
+      // Write TIFF to file
+      if (vips_tiffsave(output, baton->output.c_str(), "strip", TRUE, "compression", VIPS_FOREIGN_TIFF_COMPRESSION_JPEG, "Q", baton->quality, NULL)) {
+        return resize_error(baton, output);
+      }
+    } else {
+      (baton->err).append("Unsupported output " + baton->output);
+    }
+    g_object_unref(output);
+
+    // Clean up libvips' per-request data and threads
+    vips_error_clear();
+    vips_thread_shutdown();
+  }
+
+  void HandleOKCallback () {
+    NanScope();
+
+    Handle<Value> argv[3] = { NanNull(), NanNull(),  NanNull() };
+    if (!baton->err.empty()) {
+      // Error
+      argv[0] = NanNew<String>(baton->err.data(), baton->err.size());
+    } else {
+      // Info Object
+      Local<Object> info = NanNew<Object>();
+      info->Set(NanNew<String>("width"), NanNew<Number>(baton->width));
+      info->Set(NanNew<String>("height"), NanNew<Number>(baton->height));
+
+      if (baton->buffer_out_len > 0) {
+        // Buffer
+        argv[1] = NanNewBufferHandle((char *)baton->buffer_out, baton->buffer_out_len);
+        g_free(baton->buffer_out);
+        argv[2] = info;
+      } else {
+        // File
+        argv[1] = info;
+      }
+    }
+    delete baton;
+
+    // Decrement processing task counter
+    g_atomic_int_dec_and_test(&counter_process);
+
+    // Return to JavaScript
+    callback->Call(3, argv);
+  }
+
+ private:
+  resize_baton* baton;
+};
+
+/*
+  resize(options, output, callback)
+*/
+NAN_METHOD(resize) {
+  NanScope();
+
+  // V8 objects are converted to non-V8 types held in the baton struct
+  resize_baton *baton = new resize_baton;
+  Local<Object> options = args[0]->ToObject();
+
+  // Input filename
+  baton->file_in = *String::Utf8Value(options->Get(NanNew<String>("fileIn"))->ToString());
+  // Input Buffer object
+  if (options->Get(NanNew<String>("bufferIn"))->IsObject()) {
+    Local<Object> buffer = options->Get(NanNew<String>("bufferIn"))->ToObject();
+    baton->buffer_in_len = Buffer::Length(buffer);
+    baton->buffer_in = Buffer::Data(buffer);
+  }
+  // Output image dimensions
+  baton->width = options->Get(NanNew<String>("width"))->Int32Value();
+  baton->height = options->Get(NanNew<String>("height"))->Int32Value();
+  // Canvas options
+  Local<String> canvas = options->Get(NanNew<String>("canvas"))->ToString();
+  if (canvas->Equals(NanNew<String>("c"))) {
    baton->crop = true;
-  } else if (canvas->Equals(String::NewSymbol("w"))) {
-    baton->crop = false;
-    baton->embed = 4;
-  } else if (canvas->Equals(String::NewSymbol("b"))) {
-    baton->crop = false;
-    baton->embed = 0;
+  } else if (canvas->Equals(NanNew<String>("w"))) {
+    baton->extend = VIPS_EXTEND_WHITE;
+  } else if (canvas->Equals(NanNew<String>("b"))) {
+    baton->extend = VIPS_EXTEND_BLACK;
+  } else if (canvas->Equals(NanNew<String>("m"))) {
+    baton->max = true;
  }
-  baton->callback = Persistent<Function>::New(Local<Function>::Cast(args[5]));
+  // Other options
+  baton->gravity = options->Get(NanNew<String>("gravity"))->Int32Value();
+  baton->sharpen = options->Get(NanNew<String>("sharpen"))->BooleanValue();
+  baton->interpolator = *String::Utf8Value(options->Get(NanNew<String>("interpolator"))->ToString());
+  baton->progressive = options->Get(NanNew<String>("progressive"))->BooleanValue();
+  baton->without_enlargement = options->Get(NanNew<String>("withoutEnlargement"))->BooleanValue();
+  baton->access_method = options->Get(NanNew<String>("sequentialRead"))->BooleanValue() ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+  baton->quality = options->Get(NanNew<String>("quality"))->Int32Value();
+  baton->compressionLevel = options->Get(NanNew<String>("compressionLevel"))->Int32Value();
+  baton->angle = options->Get(NanNew<String>("angle"))->Int32Value();
+  // Output filename or __format for Buffer
+  baton->output = *String::Utf8Value(options->Get(NanNew<String>("output"))->ToString());

-  uv_work_t *work = new uv_work_t;
-  work->data = baton;
-  uv_queue_work(uv_default_loop(), work, ResizeAsync, (uv_after_work_cb)ResizeAsyncAfter);
-  return Undefined();
+  // Join queue for worker thread
+  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
+  NanAsyncQueueWorker(new ResizeWorker(callback, baton));
+
+  // Increment queued task counter
+  g_atomic_int_inc(&counter_queue);
+
+  NanReturnUndefined();
+}
+
+/*
+  Get and set cache memory and item limits
+*/
+NAN_METHOD(cache) {
+  NanScope();
+
+  // Set cache memory limit
+  if (args[0]->IsInt32()) {
+    vips_cache_set_max_mem(args[0]->Int32Value() * 1048576);
+  }
+
+  // Set cache items limit
+  if (args[1]->IsInt32()) {
+    vips_cache_set_max(args[1]->Int32Value());
+  }
+
+  // Get cache statistics
+  Local<Object> cache = NanNew<Object>();
+  cache->Set(NanNew<String>("current"), NanNew<Number>(vips_tracked_get_mem() / 1048576));
+  cache->Set(NanNew<String>("high"), NanNew<Number>(vips_tracked_get_mem_highwater() / 1048576));
+  cache->Set(NanNew<String>("memory"), NanNew<Number>(vips_cache_get_max_mem() / 1048576));
+  cache->Set(NanNew<String>("items"), NanNew<Number>(vips_cache_get_max()));
+  NanReturnValue(cache);
+}
+
+/*
+  Get internal counters (queued tasks, processing tasks)
+*/
+NAN_METHOD(counters) {
+  NanScope();
+  Local<Object> counters = NanNew<Object>();
+  counters->Set(NanNew<String>("queue"), NanNew<Number>(counter_queue));
+  counters->Set(NanNew<String>("process"), NanNew<Number>(counter_process));
+  NanReturnValue(counters);
 }

 static void at_exit(void* arg) {
-  HandleScope scope;
+  NanScope();
  vips_shutdown();
 }

 extern "C" void init(Handle<Object> target) {
-  HandleScope scope;
+  NanScope();
  vips_init("");
  AtExit(at_exit);
-  NODE_SET_METHOD(target, "resize", Resize);
-};
+  // Set libvips operation cache limits
+  vips_cache_set_max_mem(100 * 1048576); // 100 MB
+  vips_cache_set_max(500); // 500 operations
+  // Methods available to JavaScript
+  NODE_SET_METHOD(target, "metadata", metadata);
+  NODE_SET_METHOD(target, "resize", resize);
+  NODE_SET_METHOD(target, "cache", cache);
+  NODE_SET_METHOD(target, "counters", counters);
+}

-NODE_MODULE(sharp, init);
+NODE_MODULE(sharp, init)
--- a/tests/fixtures/2569067123_aca715a2ee_o.jpg
+++ b/tests/fixtures/2569067123_aca715a2ee_o.jpg
--- a/tests/fixtures/4.webp
+++ b/tests/fixtures/4.webp
--- a/tests/fixtures/50020484-00001.png
+++ b/tests/fixtures/50020484-00001.png
--- a/tests/fixtures/Crash_test.gif
+++ b/tests/fixtures/Crash_test.gif
--- a/tests/fixtures/G31D.TIF
+++ b/tests/fixtures/G31D.TIF
--- a/tests/fixtures/Landscape_8.jpg
+++ b/tests/fixtures/Landscape_8.jpg
--- a/tests/parallel.js
+++ b/tests/parallel.js
@@ -0,0 +1,37 @@
+var sharp = require("../index");
+var fs = require("fs");
+var path = require("path");
+var assert = require("assert");
+var async = require("async");
+
+var inputJpg = path.join(__dirname, "fixtures/2569067123_aca715a2ee_o.jpg"); // http://www.flickr.com/photos/grizdave/2569067123/
+var width = 720;
+var height = 480;
+
+var timer = setInterval(function() {
+  console.dir(sharp.cache());
+}, 100);
+
+async.mapSeries([1, 1, 2, 4, 8, 16, 32, 64, 128], function(parallelism, next) {
+  var start = new Date().getTime();
+  async.times(parallelism,
+    function(id, callback) {
+      sharp(inputJpg).resize(width, height).toBuffer(function(err, buffer) {
+        buffer = null;
+        callback(err, new Date().getTime() - start);
+      });
+    },
+    function(err, ids) {
+      assert(!err);
+      assert(ids.length === parallelism);
+      var mean = ids.reduce(function(a, b) {
+        return a + b;
+      }) / ids.length;
+      console.log(parallelism + " parallel calls: fastest=" + ids[0] + "ms slowest=" + ids[ids.length - 1] + "ms mean=" + mean + "ms");
+      next();
+    }
+  );
+}, function() {
+  clearInterval(timer);
+  console.dir(sharp.cache());
+});
--- a/tests/perf.js
+++ b/tests/perf.js
@@ -1,25 +1,39 @@
 var sharp = require("../index");
+var fs = require("fs");
+var path = require("path");
 var imagemagick = require("imagemagick");
+var imagemagickNative = require("imagemagick-native");
 var gm = require("gm");
-var epeg = require("epeg");
 var async = require("async");
 var assert = require("assert");
 var Benchmark = require("benchmark");

-var inputJpg = __dirname + "/2569067123_aca715a2ee_o.jpg"; // http://www.flickr.com/photos/grizdave/2569067123/
-var outputJpg = __dirname + "/output.jpg";
-var outputJpgLength = 47035;
+var fixturesPath = path.join(__dirname, "fixtures");

-var inputPng = __dirname + "/50020484-00001.png"; // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
-var outputPng = __dirname + "/output.png";
-var outputPngLength = 60380;
+var inputJpg = path.join(fixturesPath, "2569067123_aca715a2ee_o.jpg"); // http://www.flickr.com/photos/grizdave/2569067123/
+var outputJpg = path.join(fixturesPath, "output.jpg");

-var width = 640;
+var inputPng = path.join(fixturesPath, "50020484-00001.png"); // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
+var outputPng = path.join(fixturesPath, "output.png");
+
+var inputWebp = path.join(fixturesPath, "4.webp"); // http://www.gstatic.com/webp/gallery/4.webp
+var outputWebp = path.join(fixturesPath, "output.webp");
+
+var inputTiff = path.join(fixturesPath, "G31D.TIF"); // http://www.fileformat.info/format/tiff/sample/e6c9a6e5253348f4aef6d17b534360ab/index.htm
+var outputTiff = path.join(fixturesPath, "output.tiff");
+
+var inputGif = path.join(fixturesPath, "Crash_test.gif"); // http://upload.wikimedia.org/wikipedia/commons/e/e3/Crash_test.gif
+
+var width = 720;
 var height = 480;

+// Disable libvips cache to ensure tests are as fair as they can be
+sharp.cache(0);
+
 async.series({
  jpeg: function(callback) {
-    (new Benchmark.Suite("jpeg")).add("imagemagick", {
+    var inputJpgBuffer = fs.readFileSync(inputJpg);
+    (new Benchmark.Suite("jpeg")).add("imagemagick-file-file", {
      defer: true,
      fn: function(deferred) {
        imagemagick.resize({
@@ -36,10 +50,22 @@ async.series({
          }
        });
      }
-    }).add("gm", {
+    }).add("imagemagick-native-buffer-buffer", {
      defer: true,
      fn: function(deferred) {
-        gm(inputJpg).crop(width, height).quality(80).write(outputJpg, function (err) {
+        imagemagickNative.convert({
+          srcData: inputJpgBuffer,
+          quality: 80,
+          width: width,
+          height: height,
+					format: 'JPEG'
+        });
+				deferred.resolve();
+      }
+    }).add("gm-buffer-file", {
+      defer: true,
+      fn: function(deferred) {
+        gm(inputJpgBuffer).resize(width, height).quality(80).write(outputJpg, function (err) {
          if (err) {
            throw err;
          } else {
@@ -47,33 +73,198 @@ async.series({
          }
        });
      }
-    }).add("epeg", {
+    }).add("gm-buffer-buffer", {
      defer: true,
      fn: function(deferred) {
-        var image = new epeg.Image({path: inputJpg});
-        image.downsize(width, height, 80).saveTo(outputJpg);
-        deferred.resolve();
-      }
-    }).add("sharp-file", {
-      defer: true,
-      fn: function(deferred) {
-        sharp.crop(inputJpg, outputJpg, width, height, function(err) {
-          if (err) {
-            throw err;
-          } else {
-            deferred.resolve();
-          }
-        });
-      }
-    }).add("sharp-buffer", {
-      defer: true,
-      fn: function(deferred) {
-        sharp.crop(inputJpg, sharp.buffer.jpeg, width, height, function(err, buffer) {
+        gm(inputJpgBuffer).resize(width, height).quality(80).toBuffer(function (err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("gm-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        gm(inputJpg).resize(width, height).quality(80).write(outputJpg, function (err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("gm-file-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        gm(inputJpg).resize(width, height).quality(80).toBuffer(function (err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpgBuffer).resize(width, height).toFile(outputJpg, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpgBuffer).resize(width, height).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).toFile(outputJpg, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-stream-stream", {
+      defer: true,
+      fn: function(deferred) {
+        var readable = fs.createReadStream(inputJpg);
+        var writable = fs.createWriteStream(outputJpg);
+        writable.on('finish', function() {
+          deferred.resolve();
+        });
+        var pipeline = sharp().resize(width, height);
+        readable.pipe(pipeline).pipe(writable);
+      }
+    }).add("sharp-file-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-promise", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).toBuffer().then(function(buffer) {
+          assert.notStrictEqual(null, buffer);
+          deferred.resolve();
+        });
+      }
+    }).add("sharp-file-buffer-sharpen", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).sharpen().toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-bicubic", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).interpolateWith(sharp.interpolator.bicubic).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-nohalo", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).interpolateWith(sharp.interpolator.nohalo).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-locallyBoundedBicubic", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).interpolateWith(sharp.interpolator.locallyBoundedBicubic).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-vertexSplitQuadraticBasisSpline", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).interpolateWith(sharp.interpolator.vertexSplitQuadraticBasisSpline).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-progressive", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).progressive().toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-rotate", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).rotate(90).resize(width, height).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-sequentialRead", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).sequentialRead().toBuffer(function(err, buffer) {
          if (err) {
            throw err;
          } else {
            assert.notStrictEqual(null, buffer);
-            assert.strictEqual(outputJpgLength, buffer.length);
            deferred.resolve();
          }
        });
@@ -85,7 +276,8 @@ async.series({
    }).run();
  },
  png: function(callback) {
-    (new Benchmark.Suite("png")).add("imagemagick", {
+    var inputPngBuffer = fs.readFileSync(inputPng);
+    (new Benchmark.Suite("png")).add("imagemagick-file-file", {
      defer: true,
      fn: function(deferred) {
        imagemagick.resize({
@@ -101,10 +293,21 @@ async.series({
          }
        });
      }
-    }).add("gm", {
+    }).add("imagemagick-native-buffer-buffer", {
      defer: true,
      fn: function(deferred) {
-        gm(inputPng).crop(width, height).write(outputPng, function (err) {
+        imagemagickNative.convert({
+          srcData: inputPngBuffer,
+          width: width,
+          height: height,
+					format: 'PNG'
+        });
+				deferred.resolve();
+      }
+    }).add("gm-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        gm(inputPng).resize(width, height).write(outputPng, function (err) {
          if (err) {
            throw err;
          } else {
@@ -112,26 +315,84 @@ async.series({
          }
        });
      }
-    }).add("sharp-file", {
+    }).add("gm-file-buffer", {
      defer: true,
      fn: function(deferred) {
-        sharp.crop(inputPng, outputPng, width, height, function(err) {
-          if (err) {
-            throw err;
-          } else {
-            deferred.resolve();
-          }
-        });
-      }
-    }).add("sharp-buffer", {
-      defer: true,
-      fn: function(deferred) {
-        sharp.crop(inputPng, sharp.buffer.png, width, height, function(err, buffer) {
+        gm(inputPng).resize(width, height).quality(80).toBuffer(function (err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputPngBuffer).resize(width, height).toFile(outputPng, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputPngBuffer).resize(width, height).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputPng).resize(width, height).toFile(outputPng, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputPng).resize(width, height).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-sharpen", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputPng).resize(width, height).sharpen().toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-progressive", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputPng).resize(width, height).progressive().toBuffer(function(err, buffer) {
          if (err) {
            throw err;
          } else {
            assert.notStrictEqual(null, buffer);
-            assert.strictEqual(outputPngLength, buffer.length);
            deferred.resolve();
          }
        });
@@ -141,10 +402,148 @@ async.series({
    }).on("complete", function() {
      callback(null, this.filter("fastest").pluck("name"));
    }).run();
-  }
+  },
+  webp: function(callback) {
+    var inputWebpBuffer = fs.readFileSync(inputWebp);
+    (new Benchmark.Suite("webp")).add("sharp-buffer-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputWebpBuffer).resize(width, height).toFile(outputWebp, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputWebpBuffer).resize(width, height).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputWebp).resize(width, height).toFile(outputWebp, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputWebp).resize(width, height).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-sharpen", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputWebp).resize(width, height).sharpen().toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).on("cycle", function(event) {
+      console.log("webp " + String(event.target));
+    }).on("complete", function() {
+      callback(null, this.filter("fastest").pluck("name"));
+    }).run();
+  },
+  tiff: function(callback) {
+    (new Benchmark.Suite("tiff")).add("sharp-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputTiff).resize(width, height).toFile(outputTiff, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file-sharpen", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputTiff).resize(width, height).sharpen().toFile(outputTiff, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).on("cycle", function(event) {
+      console.log("tiff " + String(event.target));
+    }).on("complete", function() {
+      callback(null, this.filter("fastest").pluck("name"));
+    }).run();
+  },
+  gif: function(callback) {
+    (new Benchmark.Suite("gif")).add("sharp-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputGif).resize(width, height).toFile(outputTiff, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file-sharpen", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputGif).resize(width, height).sharpen().toFile(outputTiff, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file-sequentialRead", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputGif).sequentialRead().resize(width, height).toFile(outputTiff, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).on("cycle", function(event) {
+      console.log("gif " + String(event.target));
+    }).on("complete", function() {
+      callback(null, this.filter("fastest").pluck("name"));
+    }).run();
+  }	
 }, function(err, results) {
  assert(!err, err);
  Object.keys(results).forEach(function(format) {
-    assert.strictEqual("sharp", results[format].toString().substr(0, 5), "sharp was slower than " + results[format] + " for " + format);
+    if (results[format].toString().substr(0, 5) !== "sharp") {
+      console.log("sharp was slower than " + results[format] + " for " + format);
+    }
  });
+  console.dir(sharp.cache());
 });
--- a/tests/random.js
+++ b/tests/random.js
@@ -0,0 +1,68 @@
+var sharp = require("../index");
+var fs = require("fs");
+var path = require("path");
+var imagemagick = require("imagemagick");
+var gm = require("gm");
+var async = require("async");
+var assert = require("assert");
+var Benchmark = require("benchmark");
+
+var fixturesPath = path.join(__dirname, "fixtures");
+var inputJpg = path.join(fixturesPath, "2569067123_aca715a2ee_o.jpg"); // http://www.flickr.com/photos/grizdave/2569067123/
+var outputJpg = path.join(fixturesPath, "output.jpg");
+
+var min = 320;
+var max = 960;
+
+var randomDimension = function() {
+  return Math.random() * (max - min) + min;
+};
+
+new Benchmark.Suite("random").add("imagemagick", {
+	defer: true,
+	fn: function(deferred) {
+		imagemagick.resize({
+			srcPath: inputJpg,
+			dstPath: outputJpg,
+			quality: 0.8,
+			width: randomDimension(),
+			height: randomDimension()
+		}, function(err) {
+			if (err) {
+				throw err;
+			} else {
+				deferred.resolve();
+			}
+		});
+	}
+}).add("gm", {
+	defer: true,
+	fn: function(deferred) {
+		gm(inputJpg).resize(randomDimension(), randomDimension()).quality(80).toBuffer(function (err, buffer) {
+			if (err) {
+				throw err;
+			} else {
+				assert.notStrictEqual(null, buffer);
+				deferred.resolve();
+			}
+		});
+	}
+}).add("sharp", {
+	defer: true,
+	fn: function(deferred) {
+		sharp(inputJpg).resize(randomDimension(), randomDimension()).toBuffer(function(err, buffer) {
+			if (err) {
+				throw err;
+			} else {
+				assert.notStrictEqual(null, buffer);
+				deferred.resolve();
+			}
+		});
+	}
+}).on("cycle", function(event) {
+  console.log(String(event.target));
+}).on("complete", function() {
+  var winner = this.filter("fastest").pluck("name");
+  assert.strictEqual("sharp", String(winner), "sharp was slower than " + winner);
+	console.dir(sharp.cache());
+}).run();
--- a/tests/unit.js
+++ b/tests/unit.js
@@ -0,0 +1,549 @@
+/*jslint node: true */
+/*jslint es5: true */
+'use strict';
+
+var sharp = require("../index");
+var fs = require("fs");
+var path = require("path");
+var assert = require("assert");
+var async = require("async");
+
+var fixturesPath = path.join(__dirname, "fixtures");
+
+var inputJpg = path.join(fixturesPath, "2569067123_aca715a2ee_o.jpg"); // http://www.flickr.com/photos/grizdave/2569067123/
+var outputJpg = path.join(fixturesPath, "output.jpg");
+
+var inputTiff = path.join(fixturesPath, "G31D.TIF"); // http://www.fileformat.info/format/tiff/sample/e6c9a6e5253348f4aef6d17b534360ab/index.htm
+var outputTiff = path.join(fixturesPath, "output.tiff");
+
+var inputJpgWithExif = path.join(fixturesPath, "Landscape_8.jpg"); // https://github.com/recurser/exif-orientation-examples/blob/master/Landscape_8.jpg
+
+var inputPng = path.join(fixturesPath, "50020484-00001.png"); // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
+var inputWebp = path.join(fixturesPath, "4.webp"); // http://www.gstatic.com/webp/gallery/4.webp
+var inputGif = path.join(fixturesPath, "Crash_test.gif"); // http://upload.wikimedia.org/wikipedia/commons/e/e3/Crash_test.gif
+
+// Ensure cache limits can be set
+sharp.cache(0); // Disable
+sharp.cache(50, 500); // 50MB, 500 items
+
+async.series([
+  // Resize with exact crop
+  function(done) {
+    sharp(inputJpg).resize(320, 240).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // Resize to fixed width
+  function(done) {
+    sharp(inputJpg).resize(320).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(261, info.height);
+      done();
+    });
+  },
+  // Resize to fixed height
+  function(done) {
+    sharp(inputJpg).resize(null, 320).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(391, info.width);
+      assert.strictEqual(320, info.height);
+      done();
+    });
+  },
+  // Identity transform
+  function(done) {
+    sharp(inputJpg).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(2725, info.width);
+      assert.strictEqual(2225, info.height);
+      done();
+    });
+  },
+  // Upscale
+  function(done) {
+    sharp(inputJpg).resize(3000).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(3000, info.width);
+      assert.strictEqual(2449, info.height);
+      done();
+    });
+  },
+  // Quality
+  function(done) {
+    sharp(inputJpg).resize(320, 240).quality(70).toBuffer(function(err, buffer70) {
+      if (err) throw err;
+      sharp(inputJpg).resize(320, 240).toBuffer(function(err, buffer80) {
+        if (err) throw err;
+        sharp(inputJpg).resize(320, 240).quality(90).toBuffer(function(err, buffer90) {
+          assert(buffer70.length < buffer80.length);
+          assert(buffer80.length < buffer90.length);
+          done();
+        });
+      });
+    });
+  },
+  // TIFF with dimensions known to cause rounding errors
+  function(done) {
+    sharp(inputTiff).resize(240, 320).embedBlack().jpeg().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(240, info.width);
+      assert.strictEqual(320, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputTiff).resize(240, 320).jpeg().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(240, info.width);
+      assert.strictEqual(320, info.height);
+      done();
+    });
+  },
+  // Resize to max width or height considering ratio (landscape)
+  function(done) {
+    sharp(inputJpg).resize(320, 320).max().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(261, info.height);
+      done();
+    });
+  },
+  // Resize to max width or height considering ratio (portrait)
+  function(done) {
+    sharp(inputTiff).resize(320, 320).max().jpeg().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(243, info.width);
+      assert.strictEqual(320, info.height);
+      done();
+    });
+  },
+  // Attempt to resize to max but only provide one dimension, so should default to crop
+  function(done) {
+    sharp(inputJpg).resize(320).max().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(261, info.height);
+      done();
+    });
+  },
+  // Attempt to output to input, should fail
+  function(done) {
+    sharp(inputJpg).toFile(inputJpg, function(err) {
+      assert(!!err);
+      done();
+    });
+  },
+  // Rotate by 90 degrees, respecting output input size
+  function(done) {
+    sharp(inputJpg).rotate(90).resize(320, 240).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // Input image has Orientation EXIF tag but do not rotate output
+  function(done) {
+    sharp(inputJpgWithExif).resize(320).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(426, info.height);
+      done();
+    });
+  },
+  // Input image has Orientation EXIF tag value of 8 (270 degrees), auto-rotate
+  function(done) {
+    sharp(inputJpgWithExif).rotate().resize(320).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // Attempt to auto-rotate using image that has no EXIF
+  function(done) {
+    sharp(inputJpg).rotate().resize(320).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(261, info.height);
+      done();
+    });
+  },
+  // Rotate to an invalid angle, should fail
+  function(done) {
+    var fail = false;
+    try {
+      sharp(inputJpg).rotate(1);
+      fail = true;
+    } catch (e) {}
+    assert(!fail);
+    done();
+  },
+  // Do not enlarge the output if the input width is already less than the output width
+  function(done) {
+    sharp(inputJpg).resize(2800).withoutEnlargement().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(2725, info.width);
+      assert.strictEqual(2225, info.height);
+      done();
+    });
+  },
+  // Do not enlarge the output if the input height is already less than the output height
+  function(done) {
+    sharp(inputJpg).resize(null, 2300).withoutEnlargement().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(2725, info.width);
+      assert.strictEqual(2225, info.height);
+      done();
+    });
+  },
+  // Promises/A+
+  function(done) {
+    sharp(inputJpg).resize(320, 240).toBuffer().then(function(data) {
+      sharp(data).toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        done();
+      });
+    }).catch(function(err) {
+      throw err;
+    });
+  },
+  // Empty Buffer, should fail
+  function(done) {
+    var fail = false;
+    try {
+      sharp(new Buffer(0));
+      fail = true;
+    } catch (e) {}
+    assert(!fail);
+    done();
+  },
+  // Check colour space conversion occurs from TIFF to WebP (this used to segfault)
+  function(done) {
+    sharp(inputTiff).webp().toBuffer().then(function() {
+      done();
+    });
+  },
+  // Interpolation: bilinear
+  function(done) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.bilinear).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // Interpolation: bicubic
+  function(done) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.bicubic).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // Interpolation: nohalo
+  function(done) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.nohalo).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // Interpolation: locally bounded bicubic (LBB)
+  function(done) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.locallyBoundedBicubic).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // Interpolation: vertex split quadratic basis spline (VSQBS)
+  function(done) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.vertexSplitQuadraticBasisSpline).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+  },
+  // File-Stream
+  function(done) {
+    var writable = fs.createWriteStream(outputJpg);
+    writable.on('finish', function() {
+      sharp(outputJpg).toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        fs.unlinkSync(outputJpg);
+        done();
+      });
+    });
+    sharp(inputJpg).resize(320, 240).pipe(writable);
+  },
+  // Buffer-Stream
+  function(done) {
+    var inputJpgBuffer = fs.readFileSync(inputJpg);
+    var writable = fs.createWriteStream(outputJpg);
+    writable.on('finish', function() {
+      sharp(outputJpg).toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        fs.unlinkSync(outputJpg);
+        done();
+      });
+    });
+    sharp(inputJpgBuffer).resize(320, 240).pipe(writable);
+  },
+  // Stream-File
+  function(done) {
+    var readable = fs.createReadStream(inputJpg);
+    var pipeline = sharp().resize(320, 240).toFile(outputJpg, function(err, info) {
+      if (err) throw err;
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      fs.unlinkSync(outputJpg);
+      done();
+    });
+    readable.pipe(pipeline);
+  },
+  // Stream-Buffer
+  function(done) {
+    var readable = fs.createReadStream(inputJpg);
+    var pipeline = sharp().resize(320, 240).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
+    });
+    readable.pipe(pipeline);
+  },
+  // Stream-Stream
+  function(done) {
+    var readable = fs.createReadStream(inputJpg);
+    var writable = fs.createWriteStream(outputJpg);
+    writable.on('finish', function() {
+      sharp(outputJpg).toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        fs.unlinkSync(outputJpg);
+        done();
+      });
+    });
+    var pipeline = sharp().resize(320, 240);
+    readable.pipe(pipeline).pipe(writable);
+  },
+  // Crop, gravity=north
+  function(done) {
+    sharp(inputJpg).resize(320, 80).crop(sharp.gravity.north).toFile(path.join(fixturesPath, 'output.gravity-north.jpg'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  // Crop, gravity=east
+  function(done) {
+    sharp(inputJpg).resize(80, 320).crop(sharp.gravity.east).toFile(path.join(fixturesPath, 'output.gravity-east.jpg'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual(80, info.width);
+      assert.strictEqual(320, info.height);
+      done();
+    });
+  },
+  // Crop, gravity=south
+  function(done) {
+    sharp(inputJpg).resize(320, 80).crop(sharp.gravity.south).toFile(path.join(fixturesPath, 'output.gravity-south.jpg'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  // Crop, gravity=west
+  function(done) {
+    sharp(inputJpg).resize(80, 320).crop(sharp.gravity.west).toFile(path.join(fixturesPath, 'output.gravity-west.jpg'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual(80, info.width);
+      assert.strictEqual(320, info.height);
+      done();
+    });
+  },
+  // Crop, gravity=center
+  function(done) {
+    sharp(inputJpg).resize(320, 80).crop(sharp.gravity.center).toFile(path.join(fixturesPath, 'output.gravity-center.jpg'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  // Crop, gravity=centre
+  function(done) {
+    sharp(inputJpg).resize(80, 320).crop(sharp.gravity.centre).toFile(path.join(fixturesPath, 'output.gravity-centre.jpg'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual(80, info.width);
+      assert.strictEqual(320, info.height);
+      done();
+    });
+  },
+  // Metadata - JPEG
+  function(done) {
+    sharp(inputJpg).metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual(2725, metadata.width);
+      assert.strictEqual(2225, metadata.height);
+      assert.strictEqual('srgb', metadata.space);
+      assert.strictEqual(3, metadata.channels);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      done();
+    });
+  },
+  // Metadata - JPEG with EXIF
+  function(done) {
+    sharp(inputJpgWithExif).metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual(450, metadata.width);
+      assert.strictEqual(600, metadata.height);
+      assert.strictEqual('srgb', metadata.space);
+      assert.strictEqual(3, metadata.channels);
+      assert.strictEqual(8, metadata.orientation);
+      done();
+    });
+  },
+  // Metadata - TIFF
+  function(done) {
+    sharp(inputTiff).metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('tiff', metadata.format);
+      assert.strictEqual(2464, metadata.width);
+      assert.strictEqual(3248, metadata.height);
+      assert.strictEqual('b-w', metadata.space);
+      assert.strictEqual(1, metadata.channels);
+      done();
+    });
+  },
+  // Metadata - PNG
+  function(done) {
+    sharp(inputPng).metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('png', metadata.format);
+      assert.strictEqual(2809, metadata.width);
+      assert.strictEqual(2074, metadata.height);
+      assert.strictEqual('b-w', metadata.space);
+      assert.strictEqual(1, metadata.channels);
+      done();
+    });
+  },
+  // Metadata - WebP
+  function(done) {
+    sharp(inputWebp).metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('webp', metadata.format);
+      assert.strictEqual(1024, metadata.width);
+      assert.strictEqual(772, metadata.height);
+      assert.strictEqual('srgb', metadata.space);
+      assert.strictEqual(3, metadata.channels);
+      done();
+    });
+  },
+  // Metadata - GIF (via libmagick)
+  function(done) {
+    sharp(inputGif).metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('magick', metadata.format);
+      assert.strictEqual(800, metadata.width);
+      assert.strictEqual(533, metadata.height);
+      assert.strictEqual(3, metadata.channels);
+      done();
+    });
+  },
+  // Metadata - Promise
+  function(done) {
+    sharp(inputJpg).metadata().then(function(metadata) {
+      assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual(2725, metadata.width);
+      assert.strictEqual(2225, metadata.height);
+      assert.strictEqual('srgb', metadata.space);
+      assert.strictEqual(3, metadata.channels);
+      done();
+    });
+  },
+  // Metadata - Stream
+  function(done) {
+    var readable = fs.createReadStream(inputJpg);
+    var pipeline = sharp().metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual(2725, metadata.width);
+      assert.strictEqual(2225, metadata.height);
+      assert.strictEqual('srgb', metadata.space);
+      assert.strictEqual(3, metadata.channels);
+      done();
+    });
+    readable.pipe(pipeline);
+  },
+  // Get metadata then resize to half width
+  function(done) {
+    var image = sharp(inputJpg);
+    image.metadata(function(err, metadata) {
+      if (err) throw err;
+      assert.strictEqual('jpeg', metadata.format);
+      assert.strictEqual(2725, metadata.width);
+      assert.strictEqual(2225, metadata.height);
+      assert.strictEqual('srgb', metadata.space);
+      assert.strictEqual(3, metadata.channels);
+      image.resize(metadata.width / 2).toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(1362, info.width);
+        assert.strictEqual(1112, info.height);
+        done();
+      });
+    });
+  },
+  // Verify internal counters
+  function(done) {
+    var counters = sharp.counters();
+    assert.strictEqual(0, counters.queue);
+    assert.strictEqual(0, counters.process);
+    done();
+  }
+]);
Author	SHA1	Message	Date
Lovell Fuller	b877751b2d	Add support for C++11 on Mac	2014-08-24 21:41:09 +01:00
Lovell Fuller	40db482fd8	Version bumps	2014-08-24 21:40:23 +01:00
Lovell Fuller	98554e919c	Small doc improvements ahead of v0.6.0	2014-08-22 16:57:05 +01:00
Lovell Fuller	017bf1e905	Expose libvips interpolators #69	2014-08-22 16:50:24 +01:00
Lovell Fuller	6498fc3a9e	Ignore libmagick's inconsistent GIF colour spaces	2014-08-22 14:31:34 +01:00
Lovell Fuller	8ba71c94f4	Add usage example of metadata method	2014-08-22 14:27:46 +01:00
Lovell Fuller	f2f3eb76e1	Add method for fast access to image metadata #32	2014-08-22 14:17:43 +01:00
Lovell Fuller	5fe945fca8	Add gravity support to crop #45	2014-08-21 11:01:25 +01:00
Lovell Fuller	8ef0851a49	Expose libvips' op-cache max items #76	2014-08-19 20:30:21 +01:00
Lovell Fuller	e45956db6c	Correct usage examples for new Stream-based API	2014-08-18 19:34:55 +01:00
Lovell Fuller	7cc9f7e2e0	Add Xcode Command Line Tools install info #80	2014-08-18 19:11:53 +01:00
Lovell Fuller	df3903532d	Initial Duplex Stream support	2014-08-07 14:00:34 +01:00
Lovell Fuller	46456c9a2a	Clear cached warnings after success	2014-08-06 11:34:16 +01:00
Lovell Fuller	e98f2fc013	Small documentation improvement plus version bump	2014-07-20 22:46:26 +01:00
Lovell Fuller	7df7a505ee	Merge pull request #68 from chanon/master Pass additional info (width, height) to output callback	2014-07-20 22:22:34 +01:00
Chanon	d40bdcc6ac	Sends width and height as another parameter to the callback. Fixes issue #67	2014-07-20 23:52:28 +07:00
Lovell Fuller	1cce56b024	Use tile cache for interlace output Doubles performance of Adam7 interlaced PNG output	2014-07-09 23:47:04 +01:00
Lovell Fuller	2126f9afc1	Ensure xcode/clang uses cflags Silence pedantic warnings triggered by V8 in 0.11	2014-07-09 21:14:40 +01:00
Lovell Fuller	41420eedcf	Add details of Heroku buildpack, thanks @alex88 #57	2014-07-06 13:20:41 +01:00
Lovell Fuller	1b6ab19b6d	Remove fftw dependency when compiling libvips from src #57	2014-07-03 21:12:18 +01:00
Lovell Fuller	fbe5c18762	Expose depth of task queue	2014-06-25 23:21:39 +01:00
Lovell Fuller	8acb0ed5d0	Enable libvips C++ interpolators in Travis CI	2014-06-18 21:08:09 +01:00
Lovell Fuller	430e04d894	Update (and reduce) dependencies ahead of v0.5.1	2014-06-17 20:24:22 +01:00
Lovell Fuller	012edb4379	Support existing path to pkg-config lib for Heroku #57	2014-06-17 19:55:41 +01:00
Lovell Fuller	11ead360a9	Add Promises benchmark	2014-06-13 19:20:39 +01:00
Lovell Fuller	84a059d7e3	Rotate should throw Error, not String. Minor JSLint and whitespace fixes.	2014-06-13 18:57:54 +01:00
Lovell Fuller	b1b070ae5c	Revert "use native Promise if available" This reverts commit `261a90c8a2`.	2014-06-13 18:46:36 +01:00
Lovell Fuller	4eb910fec9	Add support for bicubic and Nohalo interpolation #41	2014-06-08 20:46:03 +01:00
Lovell Fuller	f0a9d82bf7	Always convert to sRGB colourspace to prevent libwebp segfault #58	2014-06-07 22:49:15 +01:00
Lovell Fuller	6d20a1ca81	Simplify gyp to support non-standard brew installs #56	2014-06-05 22:19:02 +01:00
Lovell Fuller	eca2787213	Add @jonathanong to contributors - thank you! Bump versions	2014-06-05 22:18:47 +01:00
Lovell Fuller	8d146accf3	Correct docs - callback is optional for png	2014-06-05 22:00:39 +01:00
Lovell Fuller	b635d015cd	Merge pull request #55 from jonathanong/native-promises use native Promise if available	2014-06-04 20:48:17 +01:00
Jonathan Ong	261a90c8a2	use native Promise if available	2014-06-04 09:03:37 -07:00
Lovell Fuller	4ae22b3425	Merge pull request #51 from jonathanong/deprecate-write show deprecation warning for .write()	2014-06-04 10:43:59 +01:00
Lovell Fuller	c9aa9c7723	Merge pull request #49 from jonathanong/strings-are-not-errors fix error types, support promises on convenience methods	2014-06-04 10:35:06 +01:00
Jonathan Ong	5e0b5969da	show deprecation warning for .write()	2014-06-03 20:53:37 -07:00
Jonathan Ong	ae6d5e69b1	fix error types, support promises on convenience methods closes #48	2014-06-03 20:41:15 -07:00
Lovell Fuller	5ccc2bca97	Warn about liborc 0.4.19 buffer overflows #21	2014-06-02 22:18:00 +01:00
Lovell Fuller	46b701c85c	Fail fast when input Buffer is empty #37	2014-06-02 21:11:25 +01:00
Lovell Fuller	7319533969	Add support for Promises/A+ #33	2014-06-01 11:27:30 +01:00
Lovell Fuller	9a05684302	Add withoutEnlargement option #36	2014-05-29 20:01:43 +01:00
Lovell Fuller	906311d403	Replace write() with toFile() to allow streams in the future #30	2014-05-29 19:54:43 +01:00
Lovell Fuller	4de9a2435f	Correct typo	2014-05-29 16:05:53 +01:00
Lovell Fuller	a94dd2b354	Add support for image rotation including EXIF auto-orient	2014-05-29 00:48:58 +01:00
Lovell Fuller	bc3311cbad	Version bump	2014-05-26 09:23:41 +01:00
Lovell Fuller	7b03eb89d7	Merge pull request #39 from pierreinglebert/update-nan update to nan 1.1.0	2014-05-26 09:15:35 +01:00
Pierre Inglebert	15a519ebd9	update to nan 1.1.0	2014-05-26 09:51:53 +02:00
Lovell Fuller	3f8e9f6487	Merge pull request #38 from pierreinglebert/fix-max-cropping-29 fix max factor #29	2014-05-24 11:54:59 +01:00
Pierre Inglebert	39688371a8	fix max factor #29	2014-05-24 10:29:33 +02:00
Lovell Fuller	e32faac17a	Prevent writing output file over input file - closes #28	2014-05-22 22:27:02 +01:00
Lovell Fuller	6c96bd0d37	Version bumps	2014-05-22 00:18:43 +01:00
Lovell Fuller	6b5f2028b7	Add support for 32 bit Linux #27	2014-05-21 23:46:10 +01:00
Lovell Fuller	276ba5228b	Add usage example and further unit test for new max option Simplify max vs crop logic	2014-05-19 21:52:47 +01:00
Lovell Fuller	ad7735a0a6	Merge pull request #18 from pierreinglebert/master Add 'max' canvas option to specify the maximum width and/or height. Approximately equivalent to GraphicsMagick's geometry option.	2014-05-19 21:03:04 +01:00
Pierre Inglebert	88edad3fae	add max option #18	2014-05-19 20:18:26 +02:00
Lovell Fuller	308d1971d8	Recalculate residual float value for affine after shrink #26 Switch to static casts for double values Add unit tests that previously would have failed	2014-05-18 11:39:05 +01:00
Lovell Fuller	6622045172	Merge pull request #25 from pierreinglebert/fix-progressive-typo Fix progressive typo	2014-05-14 11:17:41 +01:00
Pierre Inglebert	f68ba8ea57	fix progressive typo	2014-05-14 08:56:12 +02:00
Lovell Fuller	2e427bb28a	Remove liborc from CI config (to match README)	2014-05-13 16:47:57 +01:00
Lovell Fuller	efc7504961	Merge branch 'pierreinglebert-0.11-wip'	2014-05-13 16:45:32 +01:00
Lovell Fuller	8118613fa0	Merge branch '0.11-wip' of https://github.com/pierreinglebert/sharp into pierreinglebert-0.11-wip Conflicts: package.json	2014-05-13 16:45:12 +01:00
Pierre Inglebert	eb6a221cee	use master branch of image-magick-native until the 0.11 compatible is out	2014-05-13 08:03:24 +02:00
Pierre Inglebert	acdfe02502	make travis test on node 0.11	2014-05-12 21:30:44 +02:00
Lovell Fuller	2e106f8e2e	Version bumps	2014-05-12 21:15:23 +02:00
Lovell Fuller	10496881f1	Add quality and compressionLevel options for output image. #24	2014-05-12 21:15:23 +02:00
Lovell Fuller	e275f6f5dd	Add warning about liborc memory leaks. #21	2014-05-12 21:15:23 +02:00
Lovell Fuller	d635c297a2	Replace use of deprecated libvips conv method. Ensure unref of mask to fix minor memory leak of ~150 bytes/image.	2014-05-12 21:15:23 +02:00
Pierre Inglebert	817c0a2a5a	do not publish tests files	2014-05-12 21:15:23 +02:00
Pierre Inglebert	92fd34c627	remove unnecessary gitignore file	2014-05-12 21:15:23 +02:00
Lovell Fuller	43086cf134	Merge branch 'master' into quality-option	2014-05-11 18:26:16 +01:00
Lovell Fuller	e607bac31c	Version bumps	2014-05-10 20:23:08 +01:00
Lovell Fuller	f8338e7c4f	Add quality and compressionLevel options for output image. #24	2014-05-10 19:45:12 +01:00
Lovell Fuller	8322b442e0	Add warning about liborc memory leaks. #21	2014-05-10 14:39:34 +01:00
Lovell Fuller	afc51df4d8	Replace use of deprecated libvips conv method. Ensure unref of mask to fix minor memory leak of ~150 bytes/image.	2014-05-03 22:14:21 +01:00
Lovell Fuller	e3a70c1075	Merge pull request #22 from pierreinglebert/add-npmignore Add npmignore to minimise published package size	2014-04-24 14:09:42 +01:00
Pierre Inglebert	e3ee2b2976	do not publish tests files	2014-04-24 11:28:02 +02:00
Pierre Inglebert	cb285a6fb3	remove unnecessary gitignore file	2014-04-24 11:27:34 +02:00
Pierre Inglebert	aed3ca63b3	use NanNull, NanNew & NanSymbol for 0.11.11+ compat	2014-04-23 10:03:11 +02:00
Lovell Fuller	cbcf5e0dcc	Update instructions for libvips installation on Ubuntu	2014-04-18 13:09:45 +01:00
Lovell Fuller	59f5c2d31b	Update async dependency	2014-04-18 09:11:01 +01:00
Lovell Fuller	d1b47ef419	Add details of performance test task - closes #12	2014-04-16 21:55:22 +01:00
Lovell Fuller	0954ca6adf	Update performance test results	2014-04-15 22:57:27 +01:00
Lovell Fuller	c9d7f43bd9	Add gm buffer-input perf tests	2014-04-15 22:57:07 +01:00
Lovell Fuller	481741315d	Correct README markdown format	2014-04-14 22:09:08 +01:00
Lovell Fuller	cae1dbdb89	Add imagemagick-native comparison to and disable vips caching in perf tests.	2014-04-14 22:03:48 +01:00
Lovell Fuller	200d5a9312	Major version increase ahead of incoming API additions. Add link to Travis CI status.	2014-04-08 23:11:01 +01:00
Lovell Fuller	e9ca25cb45	Correct markdown typo	2014-04-08 22:40:34 +01:00
Lovell Fuller	33f24d41e7	Add Travis CI config Uses a PPA with back-ported libwebp to work around https://bugs.launchpad.net/ubuntu/+source/libwebp/+bug/1108731	2014-04-08 22:35:42 +01:00
Lovell Fuller	45d5f12a63	Add details of Ubuntu 12.04 oddities. Closes #16 .	2014-04-08 22:35:20 +01:00
Lovell Fuller	8785ca4331	Merge pull request #15 from pierreinglebert/feature-movefixtures Move test fixtures to their own directory.	2014-04-02 22:54:05 +01:00
Pierre Inglebert	1ecdf97bdb	Move fixtures to a proper directory Add test for gif (libmagick)	2014-04-02 23:42:05 +02:00
Lovell Fuller	3703ee41aa	Merge pull request #14 from pierreinglebert/feature-magickloader Add support for many other input files via the *magick libraries	2014-04-02 22:26:38 +01:00
Lovell Fuller	c8f023d8ba	Support Node.js v0.10+ only. Add @pierreinglebert credit.	2014-04-02 22:19:53 +01:00
Lovell Fuller	fe773733cd	Merge pull request #11 from pierreinglebert/master Add support for Node.js v0.11+ via nan. Remove epeg test dependency as it fails to compile on v0.11+.	2014-04-02 22:08:21 +01:00
Pierre Inglebert	19bec9346e	add libmagick load support	2014-04-02 22:17:41 +02:00
Pierre Inglebert	9bd335079f	check input files with vips foreign lib	2014-04-02 21:04:01 +02:00
Pierre Inglebert	b6dc179551	remove all references to epeg	2014-04-02 18:51:19 +02:00
Pierre Inglebert	e96fd8b9de	0.11 compat using nan	2014-04-02 00:10:42 +02:00
Lovell Fuller	6a2816e917	Add help for compiling against the gettext dependency of libvips on Mac OS #9	2014-03-13 22:16:47 +00:00
Lovell Fuller	06d88de5a2	Version bump	2014-03-12 21:11:25 +00:00
Lovell Fuller	a292e1fe8e	Add path to homebrew-installed pkgconfig for Mac OS 10.8 (10.9 is symlinked to 10.8) #9	2014-03-12 20:45:35 +00:00
Lovell Fuller	08bb35e7af	Add test dependency installation details	2014-03-11 22:44:05 +00:00
Lovell Fuller	0e89a5bbf2	Add summary of JPEG and PNG optimisation features	2014-03-10 22:32:14 +00:00
Lovell Fuller	2a0d79a78b	Minor markdown layout fix	2014-03-09 21:54:31 +00:00
Lovell Fuller	764b57022b	Minor markdown layout fix	2014-03-09 21:53:09 +00:00
Lovell Fuller	5f61331d1a	Breaking change to API to become more expressive (see #8 ). Add support for upscaling.	2014-03-09 21:44:03 +00:00
Lovell Fuller	d0e6a4c0f3	Support identity transform when both width and height are not specified	2014-03-04 22:44:53 +00:00
Lovell Fuller	f99e42d447	Add support for auto-scaling of width and height	2014-03-03 23:24:09 +00:00
Lovell Fuller	9b4387be97	Improve installation instructions for libvips	2014-02-28 23:11:05 +00:00
Lovell Fuller	9c3631ecb7	Add comparative performance tests using random dimensions	2014-02-28 22:39:02 +00:00
Lovell Fuller	31ca68fb14	Improve documentation of cache method	2014-02-28 22:37:59 +00:00
Lovell Fuller	d5d85a8697	Expose vips internal cache settings and status	2014-02-25 23:31:33 +00:00
Lovell Fuller	ae9a8b0f57	Remove unnecessary temporary copy of input buffer.	2014-02-23 10:52:40 +00:00
Lovell Fuller	0899252a72	Add support for WebP and TIFF image formats. Closes #7 .	2014-02-22 21:48:00 +00:00
Lovell Fuller	16551bc058	Take a temporary copy of buffers provided as input. Soak testing suggests this prevents the problems seen in #6 .	2014-02-12 22:36:13 +00:00
Lovell Fuller	e9d196f696	Fix (unrelated) memory leak discovered whilst investigating #6	2014-02-06 22:20:48 +00:00
Lovell Fuller	2f97d04dfa	Keep shrink-on-load logic DRY. Ensure canvas option (crop vs embed) is always as requested.	2014-02-03 23:20:38 +00:00
Lovell Fuller	e4ca8f44ec	Version bump	2014-02-01 23:00:37 +00:00
Lovell Fuller	6b3dc1e350	Ensure crop occurs on y-axis	2014-02-01 22:58:30 +00:00
Lovell Fuller	7ffcdb79e0	Add glib-2.0 path for Mac OS X	2014-01-30 18:28:24 +00:00
Lovell Fuller	10ce7c6693	Add parallel performance test to demonstrate effect of waiting for a worker thread	2014-01-26 20:16:42 +00:00
Lovell Fuller	ccd6012152	Version bump	2014-01-21 22:49:40 +00:00
Lovell Fuller	377662fffc	Ensure gm perf tests actually resize. Prevent coredump when embeding pre-shrunk image within same dimensions.	2014-01-21 22:48:33 +00:00
Lovell Fuller	d509458ba1	Major rewrite and therefore API change. Despite the name, image sharpening is now optional, plus there are other new options. Can now handle buffers in and out. Doubled performance in certain cases. Closes #3 . Closes #4 .	2014-01-19 21:38:37 +00:00
Lovell Fuller	be8f35d830	Use shrink-on-load for JPEG images, partially implementing #4 . Switch to new vip_ methods from legacy im_ methods. Large performance gains all round.	2014-01-16 22:51:44 +00:00