Improve Stream error handling #88

Correct ...magick... test dependencies
Add link to Centos 6.5 CI via snap-ci
2026-02-04 13:46:19 +01:00 · 2014-09-12 19:30:57 +01:00 · 2014-09-11 13:45:34 +01:00 · 2014-09-08 23:58:13 +01:00 · 2014-09-08 23:53:01 +01:00 · 2014-09-07 08:59:11 +01:00
12 changed files with 1707 additions and 420 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,4 @@ results
 build
 node_modules
 tests/fixtures/output.*
+tests/libvips.supp
--- a/README.md
+++ b/README.md
@@ -5,19 +5,22 @@
 * [API](https://github.com/lovell/sharp#api)
 * [Testing](https://github.com/lovell/sharp#testing)
 * [Performance](https://github.com/lovell/sharp#performance)
+* [Thanks](https://github.com/lovell/sharp#thanks)
 * [Licence](https://github.com/lovell/sharp#licence)

 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 performance of JPEG resizing is typically 8x faster than ImageMagick and GraphicsMagick, based mainly on the number of CPU cores available. Everything remains non-blocking thanks to _libuv_ and Promises/A+ are supported.
+The performance of JPEG resizing is typically 8x faster than ImageMagick and GraphicsMagick, based mainly on the number of CPU cores available.

-This module supports reading and writing images of JPEG, PNG and WebP to and from both Buffer objects and the filesystem. It also supports reading images of many other types from the filesystem via libmagick++ or libgraphicsmagick++ if present.
+Memory usage is kept to a minimum, no child processes are spawned, everything remains non-blocking thanks to _libuv_ and Promises/A+ are supported.
+
+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.

 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/).

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

-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.
+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).

 ## Installation

@@ -34,6 +37,10 @@ _libvips_ can take advantage of [liborc](http://code.entropywave.com/orc/) if pr

 	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
@@ -48,7 +55,7 @@ The _gettext_ dependency of _libvips_ [can lead](https://github.com/lovell/sharp

 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
+	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 libmagickwand-dev
 	git clone https://github.com/jcupitt/libvips.git
 	cd libvips
 	git checkout 7.38
@@ -68,6 +75,25 @@ Requires `libtiff4-dev` instead of `libtiff5-dev` and has [a bug](https://bugs.l

 Then follow Ubuntu 13.x instructions.

+### Install libvips on Redhat/Centos Linux
+
+#### Centos 6
+
+	sudo yum groupinstall -y "Development Tools"
+	sudo yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel ImageMagick-devel
+	sudo yum install -y http://li.nux.ro/download/nux/dextop/el6/x86_64/nux-dextop-release-0-2.el6.nux.noarch.rpm
+	sudo yum install -y --enablerepo=nux-dextop gobject-introspection-devel
+	sudo yum install -y http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
+	sudo yum install -y --enablerepo=remi libwebp-devel
+	git clone https://github.com/jcupitt/libvips.git
+	cd libvips
+	git checkout 7.40
+	./bootstrap.sh
+	./configure --prefix=/usr --enable-docs=no --enable-debug=no --enable-cxx=yes --without-orc --without-python --without-fftw
+	make
+	sudo make install
+	sudo ldconfig
+
 ### 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.
@@ -89,29 +115,75 @@ sharp('input.jpg').resize(300, 200).toFile('output.jpg', function(err) {
 ```

 ```javascript
-sharp('input.jpg').rotate().resize(null, 200).progressive().toBuffer(function(err, outputBuffer) {
-  if (err) {
-    throw err;
-  }
-  // outputBuffer contains 200px high progressive JPEG image data, auto-rotated using EXIF Orientation tag
+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('input.png').rotate(180).resize(300).sharpen().quality(90).webp().then(function(outputBuffer) {
-  // outputBuffer contains 300px wide, upside down, sharpened, 90% quality WebP image data
-});
+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);
 ```

 ```javascript
-sharp(inputBuffer).resize(200, 300).bicubicInterpolation().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 buffer
-});
+sharp('input.png')
+  .rotate(180)
+  .resize(300)
+  .sharpen()
+  .withMetadata()
+  .quality(90)
+  .webp()
+  .toBuffer()
+  .then(function(outputBuffer) {
+    // outputBuffer contains 300px wide, upside down, sharpened,
+    // with metadata, 90% quality WebP image data
+  });
 ```

 ```javascript
-sharp('input.gif').resize(200, 300).embedBlack().webp(function(err, outputBuffer) {
+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;
  }
@@ -121,7 +193,7 @@ sharp('input.gif').resize(200, 300).embedBlack().webp(function(err, outputBuffer
 ```

 ```javascript
-sharp(inputBuffer).resize(200, 200).max().jpeg().then(function(outputBuffer) {
+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
 });
@@ -129,14 +201,43 @@ sharp(inputBuffer).resize(200, 200).max().jpeg().then(function(outputBuffer) {

 ## API

-### sharp(input)
+### Input methods

-Constructor to which further methods are chained. `input` can be one of:
+#### 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.

-### resize(width, [height])
+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.

@@ -144,25 +245,29 @@ Scale output to `width` x `height`. By default, the resized image is cropped to

 `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()
+#### crop([gravity])

 Crop the resized image to the exact size specified, the default behaviour.

-### max()
+`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()
+#### embedWhite()

 Embed the resized image on a white background of the exact size specified.

-### embedBlack()
+#### embedBlack()

 Embed the resized image on a black background of the exact size specified.

-### rotate([angle])
+#### rotate([angle])

 Rotate the output image by either an explicit angle or auto-orient based on the EXIF `Orientation` tag.

@@ -170,114 +275,170 @@ Rotate the output image by either an explicit angle or auto-orient based on the

 Use this method without `angle` to determine the angle from EXIF data. Mirroring is currently unsupported.

-### withoutEnlargement()
+#### 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()
+#### sharpen()

 Perform a mild sharpen of the resultant image. This typically reduces performance by 30%.

-### bilinearInterpolation()
+#### interpolateWith(interpolator)

-Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation) for image resizing, the default (and fastest) interpolation if none is specified.
+Use the given interpolator for image resizing, where `interpolator` is an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.bicubic`.

-### bicubicInterpolation()
+Possible interpolators, in order of performance, are:

-Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) for image resizing. This typically reduces performance by 5%.
+* `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation), suitable for image enlargement only.
+* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), the default and fastest image reduction 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" 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.

-### nohaloInterpolation()
+#### gamma([gamma])

-Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/) for image resizing. This typically reduces performance by a factor of 2.
+Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of `1/gamma` then increasing the encoding (brighten) post-resize at a factor of `gamma`.

-### progressive()
+`gamma`, if present, is a Number betweem 1 and 3. The default value is `2.2`, a suitable approximation for sRGB images.

-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.
+This can improve the perceived brightness of a resized image in non-linear colour spaces.

-### quality(quality)
+JPEG input images will not take advantage of the shrink-on-load performance optimisation when applying a gamma correction.
+
+### Output options
+
+#### jpeg()
+
+Use JPEG format for the output image.
+
+#### png()
+
+Use PNG format for the output image.
+
+#### webp()
+
+Use WebP format for the output image.
+
+#### 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)
+#### 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.
+
+#### withMetadata([boolean])
+
+Include all metadata (ICC, EXIF, XMP) from the input image in the output image. The default behaviour is to strip all metadata.
+
+#### 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.

-### sequentialRead()
+### Output methods

-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.
-
-### toFile(filename, [callback])
+#### 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 a single argument `(err)` containing an error message, if any.
+`callback`, if present, is called with two arguments `(err, info)` where:
+
+* `err` contains an error message, if any.
+* `info` contains the output image `format`, `width` and `height`.

 A Promises/A+ promise is returned when `callback` is not provided.

-### toBuffer([callback])
+#### toBuffer([callback])

-Write image data to a Buffer, the format of which will match the input image. JPEG, PNG and WebP are supported.
+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 two arguments `(err, buffer)` where `err` is an error message, if any, and `buffer` is the resultant image data.
+`callback`, if present, gets three arguments `(err, buffer, info)` where:
+
+* `err` is an error message, if any.
+* `buffer` is the output image data.
+* `info` contains the output image `format`, `width` and `height`.

 A Promises/A+ promise is returned when `callback` is not provided.

-### jpeg([callback])
+### Utility methods

-Write JPEG image data to a Buffer.
+#### sharp.cache([memory], [items])

-`callback`, if present, gets two arguments `(err, buffer)` where `err` is an error message, if any, and `buffer` is the resultant JPEG image data.
+If `memory` or `items` are provided, set the limits of _libvips'_ operation cache.

-A Promises/A+ promise is returned when `callback` is not provided.
-
-### png([callback])
-
-Write PNG image data to a Buffer.
-
-`callback`, if present, gets two arguments `(err, buffer)` where `err` is an error message, if any, and `buffer` is the resultant PNG image data.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-### webp([callback])
-
-Write WebP image data to a Buffer.
-
-`callback`, if present, gets two arguments `(err, buffer)` where `err` is an error message, if any, and `buffer` is the resultant WebP image data.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-### sharp.cache([limit])
-
-If `limit` is provided, set the (soft) limit of _libvips_ working/cache memory to this value in MB. The default value is 100.
+* `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.

-Warnings such as _Application transferred too many scanlines_ are a good indicator you've set this value too low.
+```javascript
+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}
+```
+
+#### sharp.concurrency([threads])
+
+`threads`, if provided, is the Number of threads _libvips'_ should create for image processing. The default value is the number of CPU cores. A value of `0` will reset to this default.
+
+This method always returns the current concurrency.

 ```javascript
-var stats = sharp.cache(); // { current: 98, high: 115, limit: 100, queue: 0 }
-sharp.cache(200); // { current: 98, high: 115, limit: 200, queue: 0 }
-sharp.cache(50); // { current: 49, high: 115, limit: 50, queue: 0 }
+var threads = sharp.concurrency(); // 4
+sharp.concurrency(2); // 2
+sharp.concurrency(0); // 4
+```
+
+#### sharp.counters()
+
+Provides access to internal task counters.
+
+* `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.
+
+```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)
+### Ubuntu 12.04

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

-Running the tests requires both ImageMagick and GraphicsMagick plus one of either libmagick++-dev or libgraphicsmagick++.
+### Centos 6.5

-	brew install imagemagick
-	brew install graphicsmagick
+[![Centos 6.5 Build Status](https://snap-ci.com/lovell/sharp/branch/master/build_image)](https://snap-ci.com/lovell/sharp/branch/master)

-	sudo apt-get install imagemagick graphicsmagick libmagick++-dev
+### It worked on my machine
+
+```
+npm test
+```
+
+Running the comparative performance tests requires _ImageMagick_ and _GraphicsMagick_.
+
+```
+brew install imagemagick
+brew install graphicsmagick
+```
+
+```
+sudo apt-get install -qq imagemagick graphicsmagick
+```
+
+```
+sudo yum install ImageMagick
+sudo yum install -y http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
+sudo yum install -y --enablerepo=epel GraphicsMagick
+```

 ## Performance

@@ -318,9 +479,21 @@ Decompress a 2725x2225 JPEG image, resize and crop to 720x480, then compress to

 You can expect much greater performance with caching enabled (default) and using 16+ core machines.

+## Thanks
+
+This module would never have been possible without the help and code contributions of the following people:
+
+* [John Cupitt](https://github.com/jcupitt)
+* [Pierre Inglebert](https://github.com/pierreinglebert)
+* [Jonathan Ong](https://github.com/jonathanong)
+* [Chanon Sajjamanochai](https://github.com/chanon)
+* [Juliano Julio](https://github.com/julianojulio)
+
+Thank you!
+
 ## Licence

-Copyright 2013, 2014 Lovell Fuller and Pierre Inglebert
+Copyright 2013, 2014 Lovell Fuller and contributors.

 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
@@ -13,9 +13,11 @@
      '<!(node -e "require(\'nan\')")'
    ],
    'cflags': ['-fexceptions', '-Wall', '-O3'],
-    'cflags_cc': ['-fexceptions', '-Wall', '-O3'],
+    'cflags_cc': ['-std=c++0x', '-fexceptions', '-Wall', '-O3'],
    'xcode_settings': {
-      'OTHER_CFLAGS': ['-fexceptions', '-Wall', '-O3']
+      '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,6 +1,8 @@
 /*jslint node: true */
 'use strict';

+var util = require('util');
+var stream = require('stream');
 var Promise = require('bluebird');
 var sharp = require('./build/Release/sharp');

@@ -8,37 +10,84 @@ 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',
+    gamma: 0,
    progressive: false,
    sequentialRead: false,
    quality: 80,
    compressionLevel: 6,
-    output: '__jpeg'
+    streamIn: false,
+    streamOut: false,
+    withMetadata: false,
+    output: '__input'
  };
  if (typeof input === 'string') {
+    // input=file
    this.options.fileIn = input;
-  } else if (typeof input ==='object' && input instanceof Buffer) {
+  } 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 {
-    throw new Error('Unsupported input ' + typeof input);
+    // input=stream
+    this.options.streamIn = true;
  }
  return this;
 };
 module.exports = Sharp;
+util.inherits(Sharp, stream.Duplex);

-Sharp.prototype.crop = function() {
+/*
+  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;
 };

@@ -88,26 +137,47 @@ Sharp.prototype.sharpen = function(sharpen) {
 };

 /*
-  Use bilinear interpolation for the affine transformation (fastest, default)
+  Set the interpolator to use for the affine transformation
 */
-Sharp.prototype.bilinearInterpolation = function() {
-  this.options.interpolator = 'bilinear';
+module.exports.interpolator = {
+  nearest: 'nearest',
+  bilinear: 'bilinear',
+  bicubic: 'bicubic',
+  nohalo: 'nohalo',
+  locallyBoundedBicubic: 'lbb',
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+Sharp.prototype.interpolateWith = function(interpolator) {
+  this.options.interpolator = interpolator;
  return this;
 };

 /*
-  Use bicubic interpolation for the affine transformation
+  Deprecated interpolation methods, to be removed in v0.7.0
 */
-Sharp.prototype.bicubicInterpolation = function() {
-  this.options.interpolator = 'bicubic';
-  return this;
-};
+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');

 /*
-  Use Nohalo interpolation for the affine transformation
+  Darken image pre-resize (1/gamma) and brighten post-resize (gamma).
+  Improves brightness of resized image in non-linear colour spaces.
 */
-Sharp.prototype.nohaloInterpolation = function() {
-  this.options.interpolator = 'nohalo';
+Sharp.prototype.gamma = function(gamma) {
+  if (typeof gamma === 'undefined') {
+    // Default gamma correction of 2.2 (sRGB)
+    this.options.gamma = 2.2;
+  } else if (!Number.isNaN(gamma) && gamma >= 1 && gamma <= 3) {
+    this.options.gamma = gamma;
+  } else {
+    throw new Error('Invalid gamma correction (1.0 to 3.0) ' + gamma);
+  }
  return this;
 };

@@ -139,6 +209,11 @@ Sharp.prototype.compressionLevel = function(compressionLevel) {
  return this;
 };

+Sharp.prototype.withMetadata = function(withMetadata) {
+    this.options.withMetadata = (typeof withMetadata === 'boolean') ? withMetadata : true;
+    return this;
+};
+
 Sharp.prototype.resize = function(width, height) {
  if (!width) {
    this.options.width = -1;
@@ -181,61 +256,199 @@ Sharp.prototype.toFile = function(output, callback) {
        return Promise.reject(errOutputIsInput);
      }
    } else {
-      return this._sharp(output, callback);
+      this.options.output = output;
+      return this._sharp(callback);
    }
  }
  return this;
 };

-// Deprecated to make way for future stream support - remove in v0.6.0
-Sharp.prototype.write = require('util').deprecate(
-  Sharp.prototype.toFile,
-  '.write() is deprecated and will be removed in v0.6.0. Use .toFile() instead.'
-);
-
 Sharp.prototype.toBuffer = function(callback) {
-  return this._sharp('__input', callback);
+  return this._sharp(callback);
 };

-Sharp.prototype.jpeg = function(callback) {
-  return this._sharp('__jpeg', 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(callback) {
-  return this._sharp('__png', callback);
+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(callback) {
-  return this._sharp('__webp', callback);
+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 and promise variants
+  Supports callback, stream and promise variants
 */
-Sharp.prototype._sharp = function(output, callback) {
+Sharp.prototype._sharp = function(callback) {
+  var that = this;
  if (typeof callback === 'function') {
-    // I like callbacks
-    sharp.resize(this.options, output, callback);
+    // 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) {
+            that.emit('error', new Error(err));
+          } else {
+            that.push(data);
+          }
+          that.push(null);
+        });
+      });
+    } else {
+      // output=stream, input=file/buffer
+      sharp.resize(this.options, function(err, data) {
+        if (err) {
+          that.emit('error', new Error(err));
+        } else {
+          that.push(data);
+        }
+        that.push(null);
+      });
+    }
    return this;
  } else {
-    // I like promises
-    var options = this.options;
-    return new Promise(function(resolve, reject) {
-      sharp.resize(options, output, function(err, data) {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(data);
-        }
+    // 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);
+          }
+        });
+      });
+    }
  }
 };

-module.exports.cache = function(limit) {
-  if (Number.isNaN(limit)) {
-    limit = null;
+/*
+  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);
+          }
+        });
+      });
+    }
  }
-  return sharp.cache(limit);
+};
+
+/*
+  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 and set size of thread pool
+*/
+module.exports.concurrency = function(concurrency) {
+  if (Number.isNaN(concurrency)) {
+    concurrency = null;
+  }
+  return sharp.concurrency(concurrency);
+};
+
+/*
+  Get internal counters
+*/
+module.exports.counters = function() {
+  return sharp.counters();
 };
--- a/package.json
+++ b/package.json
@@ -1,10 +1,12 @@
 {
  "name": "sharp",
-  "version": "0.5.2",
+  "version": "0.6.2",
  "author": "Lovell Fuller <npm@lovell.info>",
  "contributors": [
    "Pierre Inglebert <pierre.inglebert@gmail.com>",
-    "Jonathan Ong <jonathanrichardong@gmail.com>"
+    "Jonathan Ong <jonathanrichardong@gmail.com>",
+    "Chanon Sajjamanochai <chanon.s@gmail.com>",
+    "Juliano Julio <julianojulio@gmail.com>"
  ],
  "description": "High performance Node.js module to resize JPEG, PNG and WebP images using the libvips library",
  "scripts": {
@@ -29,11 +31,12 @@
    "libvips",
    "vips",
    "fast",
-    "buffer"
+    "buffer",
+    "stream"
  ],
  "dependencies": {
-    "nan": "^1.2.0",
-    "bluebird": "^2.2.1"
+    "nan": "^1.3.0",
+    "bluebird": "^2.3.2"
  },
  "devDependencies": {
    "imagemagick": "^0.1.3",
--- a/src/sharp.cc
+++ b/src/sharp.cc
@@ -3,6 +3,7 @@
 #include <math.h>
 #include <string>
 #include <string.h>
+#include <tuple>
 #include <vips/vips.h>

 #include "nan.h"
@@ -14,16 +15,19 @@ struct resize_baton {
  std::string file_in;
  void* buffer_in;
  size_t buffer_in_len;
-  std::string file_out;
+  std::string output;
+  std::string output_format;
  void* buffer_out;
  size_t buffer_out_len;
  int width;
  int height;
  bool crop;
+  int gravity;
  bool max;
  VipsExtend extend;
  bool sharpen;
  std::string interpolator;
+  double gamma;
  bool progressive;
  bool without_enlargement;
  VipsAccess access_method;
@@ -31,18 +35,24 @@ struct resize_baton {
  int compressionLevel;
  int angle;
  std::string err;
+  bool withMetadata;

  resize_baton():
    buffer_in_len(0),
+    output_format(""),
    buffer_out_len(0),
    crop(false),
+    gravity(0),
    max(false),
    sharpen(false),
+    gamma(0.0),
    progressive(false),
-    without_enlargement(false) {}
+    without_enlargement(false),
+    withMetadata(false) {}
 };

 typedef enum {
+  UNKNOWN,
  JPEG,
  PNG,
  WEBP,
@@ -55,7 +65,9 @@ unsigned char const MARKER_PNG[] = {0x89, 0x50};
 unsigned char const MARKER_WEBP[] = {0x52, 0x49};

 // How many tasks are in the queue?
-volatile int queue_length = 0;
+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);
@@ -92,7 +104,8 @@ static void resize_error(resize_baton *baton, VipsImage *unref) {
   2. Use input image EXIF Orientation header (does not support mirroring)
   3. Otherwise default to zero, i.e. no rotation
 */
-static VipsAngle calc_rotation(int const angle, VipsImage const *input) {
+static VipsAngle
+sharp_calc_rotation(int const angle, VipsImage const *input) {
  VipsAngle rotate = VIPS_ANGLE_0;
  if (angle == -1) {
    const char *exif;
@@ -117,64 +130,253 @@ static VipsAngle calc_rotation(int const angle, VipsImage const *input) {
  return rotate;
 }

-class ResizeWorker : public NanAsyncWorker {
- public:
-  ResizeWorker(NanCallback *callback, resize_baton *baton)
-    : NanAsyncWorker(callback), baton(baton) {}
-  ~ResizeWorker() {}
+/*
+  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);
+}

-  void Execute () {
-    // Input
-    ImageType inputImageType = JPEG;
-    VipsImage *in = vips_image_new();
+/*
+  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) {
-      if (memcmp(MARKER_JPEG, baton->buffer_in, 2) == 0) {
-        if (vips_jpegload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "access", baton->access_method, NULL)) {
-          return resize_error(baton, in);
-        }
-      } else if(memcmp(MARKER_PNG, baton->buffer_in, 2) == 0) {
-        inputImageType = PNG;
-        if (vips_pngload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "access", baton->access_method, NULL)) {
-          return resize_error(baton, in);
-        }
-      } else if(memcmp(MARKER_WEBP, baton->buffer_in, 2) == 0) {
-        inputImageType = WEBP;
-        if (vips_webpload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "access", baton->access_method, NULL)) {
-          return resize_error(baton, in);
-        }
-      } else {
-        resize_error(baton, in);
-        (baton->err).append("Unsupported input buffer");
-        return;
-      }
-    } else if (vips_foreign_is_a("jpegload", baton->file_in.c_str())) {
-      if (vips_jpegload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
-        return resize_error(baton, in);
-      }
-    } else if (vips_foreign_is_a("pngload", baton->file_in.c_str())) {
-      inputImageType = PNG;
-      if (vips_pngload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
-        return resize_error(baton, in);
-      }
-    } else if (vips_foreign_is_a("webpload", baton->file_in.c_str())) {
-      inputImageType = WEBP;
-      if (vips_webpload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
-        return resize_error(baton, in);
-      }
-    } else if (vips_foreign_is_a("tiffload", baton->file_in.c_str())) {
-      inputImageType = TIFF;
-      if (vips_tiffload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
-        return resize_error(baton, in);
-      }
-    } else if(vips_foreign_is_a("magickload", (baton->file_in).c_str())) {
-      inputImageType = MAGICK;
-      if (vips_magickload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
-        return resize_error(baton, in);
+      // 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 {
-      resize_error(baton, in);
-      (baton->err).append("Unsupported input file " + baton->file_in);
-      return;
+      // 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();
+  }
+
+  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();
+}
+
+// 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
@@ -182,7 +384,7 @@ class ResizeWorker : public NanAsyncWorker {
    int inputHeight = in->Ysize;

    // Calculate angle of rotation, to be carried out later
-    VipsAngle rotation = calc_rotation(baton->angle, in);
+    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;
@@ -236,9 +438,9 @@ class ResizeWorker : public NanAsyncWorker {
      }
    }

-    // Try to use libjpeg shrink-on-load
+    // Try to use libjpeg shrink-on-load, but not when applying gamma correction
    int shrink_on_load = 1;
-    if (inputImageType == JPEG) {
+    if (inputImageType == JPEG && baton->gamma == 0) {
      if (shrink >= 8) {
        factor = factor / 8;
        shrink_on_load = 8;
@@ -271,6 +473,16 @@ class ResizeWorker : public NanAsyncWorker {
    }
    g_object_unref(in);

+    // Gamma encoding (darken)
+    if (baton->gamma >= 1 && baton->gamma <= 3) {
+      VipsImage *gamma_encoded = vips_image_new();
+      if (vips_gamma(shrunk_on_load, &gamma_encoded, "exponent", 1.0 / baton->gamma, NULL)) {
+        return resize_error(baton, shrunk_on_load);
+      }
+      g_object_unref(shrunk_on_load);
+      shrunk_on_load = gamma_encoded;
+    }
+
    VipsImage *shrunk = vips_image_new();
    if (shrink > 1) {
      // Use vips_shrink with the integral reduction
@@ -330,10 +542,11 @@ class ResizeWorker : public NanAsyncWorker {
    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);
-        int left = (rotated->Xsize - width + 1) / 2;
-        int top = (rotated->Ysize - height + 1) / 2;
        if (vips_extract_area(rotated, &canvased, left, top, width, height, NULL)) {
          return resize_error(baton, rotated);
        }
@@ -368,6 +581,16 @@ class ResizeWorker : public NanAsyncWorker {
    }
    g_object_unref(canvased);

+    // Gamma decoding (brighten)
+    if (baton->gamma >= 1 && baton->gamma <= 3) {
+      VipsImage *gamma_decoded = vips_image_new();
+      if (vips_gamma(sharpened, &gamma_decoded, "exponent", baton->gamma, NULL)) {
+        return resize_error(baton, sharpened);
+      }
+      g_object_unref(sharpened);
+      sharpened = gamma_decoded;
+    }
+
    // Always convert to sRGB colour space
    VipsImage *colourspaced = vips_image_new();
    vips_colourspace(sharpened, &colourspaced, VIPS_INTERPRETATION_sRGB, NULL);
@@ -386,64 +609,104 @@ class ResizeWorker : public NanAsyncWorker {

    // Output
    VipsImage *output = cached;
-    if (baton->file_out == "__jpeg" || (baton->file_out == "__input" && inputImageType == JPEG)) {
+    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)) {
+      if (vips_jpegsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", !baton->withMetadata,
+        "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
        return resize_error(baton, output);
      }
-    } else if (baton->file_out == "__png" || (baton->file_out == "__input" && inputImageType == PNG)) {
+      baton->output_format = "jpeg";
+    } 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)) {
+      if (vips_pngsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", !baton->withMetadata,
+        "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
        return resize_error(baton, output);
      }
-    } else if (baton->file_out == "__webp" || (baton->file_out == "__input" && inputImageType == WEBP)) {
+      baton->output_format = "png";
+    } 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->file_out))  {
-      // Write JPEG to file
-      if (vips_jpegsave(output, baton->file_out.c_str(), "strip", TRUE, "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
-        return resize_error(baton, output);
-      }
-    } else if (is_png(baton->file_out)) {
-      // Write PNG to file
-      if (vips_pngsave(output, baton->file_out.c_str(), "strip", TRUE, "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
-        return resize_error(baton, output);
-      }
-    } else if (is_webp(baton->file_out)) {
-      // Write WEBP to file
-      if (vips_webpsave(output, baton->file_out.c_str(), "strip", TRUE, "Q", baton->quality, NULL)) {
-        return resize_error(baton, output);
-      }
-    } else if (is_tiff(baton->file_out)) {
-      // Write TIFF to file
-      if (vips_tiffsave(output, baton->file_out.c_str(), "strip", TRUE, "compression", VIPS_FOREIGN_TIFF_COMPRESSION_JPEG, "Q", baton->quality, NULL)) {
+      if (vips_webpsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", !baton->withMetadata,
+        "Q", baton->quality, NULL)) {
        return resize_error(baton, output);
      }
+      baton->output_format = "webp";
    } else {
-      (baton->err).append("Unsupported output " + baton->file_out);
+      bool output_jpeg = is_jpeg(baton->output);
+      bool output_png = is_png(baton->output);
+      bool output_webp = is_webp(baton->output);
+      bool output_tiff = is_tiff(baton->output);
+      bool match_input = !(output_jpeg || output_png || output_webp || output_tiff);
+      if (output_jpeg || (match_input && inputImageType == JPEG)) {
+        // Write JPEG to file
+        if (vips_jpegsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "jpeg";
+      } else if (output_png || (match_input && inputImageType == PNG)) {
+        // Write PNG to file
+        if (vips_pngsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "png";
+      } else if (output_webp || (match_input && inputImageType == WEBP)) {
+        // Write WEBP to file
+        if (vips_webpsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "Q", baton->quality, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "webp";
+      } else if (output_tiff || (match_input && inputImageType == TIFF)) {
+        // Write TIFF to file
+        if (vips_tiffsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "compression", VIPS_FOREIGN_TIFF_COMPRESSION_JPEG, "Q", baton->quality, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "tiff";
+      } else {
+        (baton->err).append("Unsupported output " + baton->output);
+        return resize_error(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[2] = { NanNull(), NanNull() };
+    Handle<Value> argv[3] = { NanNull(), NanNull(),  NanNull() };
    if (!baton->err.empty()) {
      // Error
      argv[0] = NanNew<String>(baton->err.data(), baton->err.size());
-    } else if (baton->buffer_out_len > 0) {
-      // Buffer
-      argv[1] = NanNewBufferHandle((char *)baton->buffer_out, baton->buffer_out_len);
-      g_free(baton->buffer_out);
+    } else {
+      // Info Object
+      Local<Object> info = NanNew<Object>();
+      info->Set(NanNew<String>("format"), NanNew<String>(baton->output_format));
+      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(static_cast<char*>(baton->buffer_out), baton->buffer_out_len);
+        g_free(baton->buffer_out);
+        argv[2] = info;
+      } else {
+        // File
+        argv[1] = info;
+      }
    }
    delete baton;
-    callback->Call(2, argv);
-    // Decrement queue length
-    g_atomic_int_dec_and_test(&queue_length);
+
+    // Decrement processing task counter
+    g_atomic_int_dec_and_test(&counter_process);
+
+    // Return to JavaScript
+    callback->Call(3, argv);
  }

 private:
@@ -483,44 +746,85 @@ NAN_METHOD(resize) {
    baton->max = true;
  }
  // 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->gamma = options->Get(NanNew<String>("gamma"))->NumberValue();
  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();
+  baton->withMetadata = options->Get(NanNew<String>("withMetadata"))->BooleanValue();
  // Output filename or __format for Buffer
-  baton->file_out = *String::Utf8Value(args[1]->ToString());
+  baton->output = *String::Utf8Value(options->Get(NanNew<String>("output"))->ToString());

  // Join queue for worker thread
-  NanCallback *callback = new NanCallback(args[2].As<v8::Function>());
+  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
  NanAsyncQueueWorker(new ResizeWorker(callback, baton));

-  // Increment queue length
-  g_atomic_int_inc(&queue_length);
+  // 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 limit
+  // Set cache memory limit
  if (args[0]->IsInt32()) {
-    vips_cache_set_max_mem(args[0]->Int32Value() * 1048576);
+    int newMax = args[0]->Int32Value() * 1048576;
+    int oldMax = vips_cache_get_max_mem();
+    vips_cache_set_max_mem(newMax);
+
+    // Notify the V8 garbage collector of delta in max cache size
+    NanAdjustExternalMemory(newMax - oldMax);
+  }
+
+  // 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>("limit"), NanNew<Number>(vips_cache_get_max_mem() / 1048576));
-  cache->Set(NanNew<String>("queue"), NanNew<Number>(queue_length));
+  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 and set size of thread pool
+*/
+NAN_METHOD(concurrency) {
+  NanScope();
+
+  // Set concurrency
+  if (args[0]->IsInt32()) {
+    vips_concurrency_set(args[0]->Int32Value());
+  }
+  // Get concurrency
+  NanReturnValue(NanNew<Number>(vips_concurrency_get()));
+}
+
+/*
+  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) {
  NanScope();
  vips_shutdown();
@@ -528,10 +832,22 @@ static void at_exit(void* arg) {

 extern "C" void init(Handle<Object> target) {
  NanScope();
-  vips_init("");
+  vips_init("sharp");
  AtExit(at_exit);
+
+  // Set libvips operation cache limits
+  vips_cache_set_max_mem(100 * 1048576); // 100 MB
+  vips_cache_set_max(500); // 500 operations
+
+  // Notify the V8 garbage collector of max cache size
+  NanAdjustExternalMemory(vips_cache_get_max_mem());
+
+  // 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, "concurrency", concurrency);
+  NODE_SET_METHOD(target, "counters", counters);
 }

 NODE_MODULE(sharp, init)
--- a/tests/fixtures/gamma_dalai_lama_gray.jpg
+++ b/tests/fixtures/gamma_dalai_lama_gray.jpg
--- a/tests/leak.sh
+++ b/tests/leak.sh
@@ -0,0 +1,7 @@
+if ! type valgrind >/dev/null; then
+  echo "Please install valgrind before running memory leak tests"
+  exit 1
+fi
+
+curl -O https://raw.githubusercontent.com/jcupitt/libvips/master/libvips.supp
+G_SLICE=always-malloc G_DEBUG=gc-friendly valgrind --suppressions=libvips.supp --suppressions=sharp.supp --leak-check=full --show-leak-kinds=definite,indirect,possible node unit.js
--- a/tests/parallel.js
+++ b/tests/parallel.js
@@ -1,37 +1,39 @@
-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());
-});
+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;
+
+sharp.concurrency(1);
+
+var timer = setInterval(function() {
+  console.dir(sharp.counters());
+}, 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.counters());
+});
--- a/tests/perf.js
+++ b/tests/perf.js
@@ -142,6 +142,17 @@ async.series({
          }
        });
      }
+    }).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) {
@@ -174,10 +185,22 @@ async.series({
          }
        });
      }
+    }).add("sharp-file-buffer-nearest-neighbour", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).interpolateWith(sharp.interpolator.nearest).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).bicubicInterpolation().toBuffer(function(err, buffer) {
+        sharp(inputJpg).resize(width, height).interpolateWith(sharp.interpolator.bicubic).toBuffer(function(err, buffer) {
          if (err) {
            throw err;
          } else {
@@ -189,7 +212,43 @@ async.series({
    }).add("sharp-file-buffer-nohalo", {
      defer: true,
      fn: function(deferred) {
-        sharp(inputJpg).resize(width, height).nohaloInterpolation().toBuffer(function(err, buffer) {
+        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-gamma", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).gamma().toBuffer(function(err, buffer) {
          if (err) {
            throw err;
          } else {
--- a/tests/sharp.supp
+++ b/tests/sharp.supp
@@ -0,0 +1,111 @@
+# libjpeg warnings
+{
+  cond_jpeg_read_scanlines
+  Memcheck:Cond
+  ...
+  fun:jpeg_read_scanlines
+}
+{
+  value_jpeg_read_scanlines
+  Memcheck:Value8
+  ...
+  fun:jpeg_read_scanlines
+}
+{
+  cond_jpeg_write_scanlines
+  Memcheck:Cond
+  ...
+  fun:jpeg_write_scanlines
+}
+{
+  cond_jpeg_finish_compress
+  Memcheck:Cond
+  ...
+  fun:jpeg_finish_compress
+}
+{
+  value_jpeg_finish_compress
+  Memcheck:Value8
+  ...
+  fun:jpeg_finish_compress
+}
+
+# libvips interpolator warnings
+{
+  cond_libvips_interpolate_lbb
+  Memcheck:Cond
+  ...
+  fun:_ZL32vips_interpolate_lbb_interpolateP16_VipsInterpolatePvP11_VipsRegiondd
+  fun:vips_affine_gen
+}
+
+# libuv warnings
+{
+  free_libuv
+  Memcheck:Free
+  ...
+  fun:uv__work_done
+}
+
+# nodejs warnings
+{
+  param_nodejs_write_buffer
+  Memcheck:Param
+  write(buf)
+  ...
+  obj:/usr/bin/nodejs
+}
+{
+  leak_nodejs_ImmutableAsciiSource_CreateFromLiteral
+  Memcheck:Leak
+  match-leak-kinds: definite
+  ...
+  fun:_ZN4node20ImmutableAsciiSource17CreateFromLiteralEPKcm
+}
+{
+  leak_nodejs_Buffer_New
+  Memcheck:Leak
+  match-leak-kinds: definite
+  ...
+  fun:_ZN4node6Buffer3NewERKN2v89ArgumentsE
+}
+{
+  leak_nodejs_Buffer_Replace
+   Memcheck:Leak
+   match-leak-kinds: indirect,possible
+   ...
+   fun:_ZN4node6Buffer7ReplaceEPcmPFvS1_PvES2_
+}
+{
+  leak_nodejs_SignalWrap_New
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node10SignalWrap3NewERKN2v89ArgumentsE
+}
+{
+  leak_nodejs_TTYWrap_New
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node7TTYWrap3NewERKN2v89ArgumentsE
+}
+{
+  leak_nodejs_ares_init_options
+  Memcheck:Leak
+  match-leak-kinds: reachable
+  fun:malloc
+  fun:strdup
+  ...
+  fun:ares_init_options
+}
+
+# vips__init warnings
+{
+  leak_libvips_init
+  Memcheck:Leak
+  match-leak-kinds: reachable
+  fun:malloc
+  ...
+  fun:vips__init
+}
--- a/tests/unit.js
+++ b/tests/unit.js
@@ -3,8 +3,8 @@
 'use strict';

 var sharp = require("../index");
+var fs = require("fs");
 var path = require("path");
-var imagemagick = require("imagemagick");
 var assert = require("assert");
 var async = require("async");

@@ -18,74 +18,86 @@ 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 inputJpgWithGammaHoliness = path.join(fixturesPath, "gamma_dalai_lama_gray.jpg"); // http://www.4p8.com/eric.brasseur/gamma.html
+
+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
+
+// Ensure concurrency can be set
+var defaultConcurrency = sharp.concurrency();
+sharp.concurrency(16);
+assert.strictEqual(16, sharp.concurrency());
+sharp.concurrency(0);
+assert.strictEqual(defaultConcurrency, sharp.concurrency());
+
 async.series([
  // Resize with exact crop
  function(done) {
-    sharp(inputJpg).resize(320, 240).toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(320, 240).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(240, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
    });
  },
  // Resize to fixed width
  function(done) {
-    sharp(inputJpg).resize(320).toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(320).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(261, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(261, info.height);
+      done();
    });
  },
  // Resize to fixed height
  function(done) {
-    sharp(inputJpg).resize(null, 320).toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(null, 320).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(391, features.width);
-        assert.strictEqual(320, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(391, info.width);
+      assert.strictEqual(320, info.height);
+      done();
    });
  },
  // Identity transform
  function(done) {
-    sharp(inputJpg).toFile(outputJpg, function(err) {
+    sharp(inputJpg).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(2725, features.width);
-        assert.strictEqual(2225, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(2725, info.width);
+      assert.strictEqual(2225, info.height);
+      done();
    });
  },
  // Upscale
  function(done) {
-    sharp(inputJpg).resize(3000).toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(3000).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(3000, features.width);
-        assert.strictEqual(2449, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(3000, info.width);
+      assert.strictEqual(2449, info.height);
+      done();
    });
  },
  // Quality
  function(done) {
-    sharp(inputJpg).resize(320, 240).quality(70).jpeg(function(err, buffer70) {
+    sharp(inputJpg).resize(320, 240).quality(70).toBuffer(function(err, buffer70) {
      if (err) throw err;
-      sharp(inputJpg).resize(320, 240).jpeg(function(err, buffer80) {
+      sharp(inputJpg).resize(320, 240).toBuffer(function(err, buffer80) {
        if (err) throw err;
-        sharp(inputJpg).resize(320, 240).quality(90).jpeg(function(err, buffer90) {
+        sharp(inputJpg).resize(320, 240).quality(90).toBuffer(function(err, buffer90) {
          assert(buffer70.length < buffer80.length);
          assert(buffer80.length < buffer90.length);
          done();
@@ -95,61 +107,56 @@ async.series([
  },
  // TIFF with dimensions known to cause rounding errors
  function(done) {
-    sharp(inputTiff).resize(240, 320).embedBlack().toFile(outputJpg, function(err) {
+    sharp(inputTiff).resize(240, 320).embedBlack().jpeg().toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(240, features.width);
-        assert.strictEqual(320, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(240, info.width);
+      assert.strictEqual(320, info.height);
+      done();
    });
  },
  function(done) {
-    sharp(inputTiff).resize(240, 320).toFile(outputJpg, function(err) {
+    sharp(inputTiff).resize(240, 320).jpeg().toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(240, features.width);
-        assert.strictEqual(320, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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().toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(320, 320).max().toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(261, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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().toFile(outputJpg, function(err) {
+    sharp(inputTiff).resize(320, 320).max().jpeg().toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(243, features.width);
-        assert.strictEqual(320, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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().toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(320).max().toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(261, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(261, info.height);
+      done();
    });
  },
  // Attempt to output to input, should fail
@@ -161,50 +168,46 @@ async.series([
  },
  // Rotate by 90 degrees, respecting output input size
  function(done) {
-    sharp(inputJpg).rotate(90).resize(320, 240).toFile(outputJpg, function(err) {
+    sharp(inputJpg).rotate(90).resize(320, 240).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(240, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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).toFile(outputJpg, function(err) {
+    sharp(inputJpgWithExif).resize(320).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(426, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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).toFile(outputJpg, function(err) {
+    sharp(inputJpgWithExif).rotate().resize(320).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(240, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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).toFile(outputJpg, function(err) {
+    sharp(inputJpg).rotate().resize(320).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(261, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(261, info.height);
+      done();
    });
  },
  // Rotate to an invalid angle, should fail
@@ -219,34 +222,35 @@ async.series([
  },
  // Do not enlarge the output if the input width is already less than the output width
  function(done) {
-    sharp(inputJpg).resize(2800).withoutEnlargement().toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(2800).withoutEnlargement().toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(2725, features.width);
-        assert.strictEqual(2225, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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().toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(null, 2300).withoutEnlargement().toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(2725, features.width);
-        assert.strictEqual(2225, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(2725, info.width);
+      assert.strictEqual(2225, info.height);
+      done();
    });
  },
  // Promises/A+
  function(done) {
-    sharp(inputJpg).resize(320, 240).toFile(outputJpg).then(function() {
-      imagemagick.identify(outputJpg, function(err, features) {
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(240, features.height);
+    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('jpeg', info.format);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
        done();
      });
    }).catch(function(err) {
@@ -265,44 +269,440 @@ async.series([
  },
  // Check colour space conversion occurs from TIFF to WebP (this used to segfault)
  function(done) {
-    sharp(inputTiff).webp().then(function() {
+    sharp(inputTiff).webp().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual('webp', info.format);
+      done();
+    });
+  },
+  // Interpolation: nearest neighbour
+  function(done) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.nearest).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
      done();
    });
  },
  // Interpolation: bilinear
  function(done) {
-    sharp(inputJpg).resize(320, 240).bilinearInterpolation().toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.bilinear).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(240, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
    });
  },
  // Interpolation: bicubic
  function(done) {
-    sharp(inputJpg).resize(320, 240).bicubicInterpolation().toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.bicubic).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
-        if (err) throw err;
-        assert.strictEqual(320, features.width);
-        assert.strictEqual(240, features.height);
-        done();
-      });
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
+      done();
    });
  },
  // Interpolation: nohalo
  function(done) {
-    sharp(inputJpg).resize(320, 240).nohaloInterpolation().toFile(outputJpg, function(err) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.nohalo).toBuffer(function(err, data, info) {
      if (err) throw err;
-      imagemagick.identify(outputJpg, function(err, features) {
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      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('jpeg', info.format);
+      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('jpeg', info.format);
+      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(320, features.width);
-        assert.strictEqual(240, features.height);
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual('jpeg', info.format);
+        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('jpeg', info.format);
+        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('jpeg', info.format);
+      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('jpeg', info.format);
+      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('jpeg', info.format);
+        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);
+  },
+  // Stream-Stream error handling
+  function(done) {
+    var pipeline = sharp().resize(320, 240);
+    var anErrorWasEmitted = false;
+    pipeline.on('error', function(err) {
+      anErrorWasEmitted = !!err;
+    }).on('end', function() {
+      assert(anErrorWasEmitted);
+      done();
+    });
+    var readableButNotAnImage = fs.createReadStream(__filename);
+    var writable = fs.createWriteStream(outputJpg);
+    readableButNotAnImage.pipe(pipeline).pipe(writable);
+  },
+  // File-Stream error handling
+  function(done) {
+    var readableButNotAnImage = sharp(__filename).resize(320, 240);
+    var anErrorWasEmitted = false;
+    readableButNotAnImage.on('error', function(err) {
+      anErrorWasEmitted = !!err;
+    }).on('end', function() {
+      assert(anErrorWasEmitted);
+      done();
+    });
+    var writable = fs.createWriteStream(outputJpg);
+    readableButNotAnImage.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();
+    });
+  },
+  // Keeps Metadata after a resize
+  function(done) {
+      sharp(inputJpgWithExif).resize(320, 240).withMetadata().toBuffer(function(err, buffer) {
+          if (err) throw err;
+          sharp(buffer).metadata(function(err, metadata) {
+              if (err) throw err;
+              assert.strictEqual(8, metadata.orientation);
+              done();
+          });
+      });
+  },
+  // Keeps Metadata after a resize
+  function(done) {
+      sharp(inputJpgWithExif).resize(320, 240).withMetadata(false).toBuffer(function(err, buffer) {
+          if (err) throw err;
+          sharp(buffer).metadata(function(err, metadata) {
+              if (err) throw err;
+              assert.strictEqual('undefined', typeof metadata.orientation);
+              done();
+          });
+      });
+  },
+  // Output filename without extension should mirror input format
+  function(done) {
+    sharp(inputJpg).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputPng).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('png', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputWebP).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('webp', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputTiff).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('tiff', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputGif).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      assert(!!err);
+    });
+  },
+  // 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();
      });
    });
  },
+  // Gamma correction
+  function(done) {
+    sharp(inputJpgWithGammaHoliness).resize(129, 111).toFile(path.join(fixturesPath, 'output.gamma-0.0.jpg'), function(err) {
+      if (err) throw err;
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputJpgWithGammaHoliness).resize(129, 111).gamma().toFile(path.join(fixturesPath, 'output.gamma-2.2.jpg'), function(err) {
+      if (err) throw err;
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputJpgWithGammaHoliness).resize(129, 111).gamma(3).toFile(path.join(fixturesPath, 'output.gamma-3.0.jpg'), function(err) {
+      if (err) throw err;
+      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	515b4656e6	Improve Stream error handling #88	2014-09-12 19:30:57 +01:00
Lovell Fuller	34c96ff925	Correct ...magick... test dependencies	2014-09-11 13:45:34 +01:00
Lovell Fuller	b8a04cc4ef	Add link to Centos 6.5 CI via snap-ci	2014-09-08 23:58:13 +01:00
Lovell Fuller	ddc3f6e9c6	Add RHEL libvips installation - close #78	2014-09-08 23:53:01 +01:00
Lovell Fuller	3699e61c20	Improve support for extension-less output filenames	2014-09-07 08:59:11 +01:00
Lovell Fuller	2820218609	Add format property to output info Output format may be derived from input format	2014-09-04 11:38:05 +01:00
Lovell Fuller	eb3e739f7b	Expose libvips thread pool size	2014-09-03 19:52:03 +01:00
Lovell Fuller	87f6e83988	Add memory leak check #21 Runs unit tests via valgrind	2014-09-02 13:59:35 +01:00
Lovell Fuller	5728efd32b	Add support for gamma correction #43	2014-08-30 14:12:42 +01:00
Lovell Fuller	bac367b005	Notify V8 GC of libvips cache size #21	2014-08-26 23:28:58 +01:00
Lovell Fuller	0d89131f66	Prevent small memory leak with non-empty argv0 #21	2014-08-26 15:25:36 +01:00
Lovell Fuller	8380be4be3	Add nearest neighbour interpolation Suitable for image enlargement	2014-08-26 09:38:27 +01:00
Lovell Fuller	d0f51363bf	Re-order output option methods Add explicit list of and links to contributors	2014-08-26 09:09:01 +01:00
Lovell Fuller	15160d3b61	Merge pull request #83 from julianojulio/master Add support for maintaining metadata in output image, thanks @julianojulio #83	2014-08-26 08:31:58 +01:00
Juliano Julio Costa	c5efb77bad	New withMetadata([boolean]) to keep metadata in the generated images.	2014-08-25 15:59:21 -04:00
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