Update changelog for v0.11.1

Version bumps for benchmark test

.jshintrc

@@ -4,6 +4,7 @@
   "maxparams": 4,
   "maxcomplexity": 13,
   "globals": {
+    "before": true,
     "describe": true,
     "it": true
   }

.npmignore

@@ -7,3 +7,4 @@ coverage
 test
 .travis.yml
 appveyor.yml
+mkdocs.yml

CONTRIBUTING.md

@@ -30,9 +30,16 @@ Please select the `master` branch as the destination for your Pull Request so yo
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/master`.
 
+To test C++ changes, you can compile the module using `npm install` and then run the tests using `npm test`.
+
 ## Submit a Pull Request with a new feature
 
-Please add JavaScript [unit tests](https://github.com/lovell/sharp/tree/master/test/unit) to cover your new feature. A test coverage report for the JavaScript code is generated in the `coverage/lcov-report` directory.
+Please add JavaScript [unit tests](https://github.com/lovell/sharp/tree/master/test/unit) to cover your new feature.
+A test coverage report for the JavaScript code is generated in the `coverage/lcov-report` directory.
+
+Where possible, the functional tests use gradient-based perceptual hashes
+based on [dHash](http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html)
+to compare expected vs actual images.
 
 You deserve to add your details to the [list of contributors](https://github.com/lovell/sharp/blob/master/package.json#L5).
 
@@ -40,9 +47,9 @@ Any change that modifies the existing public API should be added to the relevant
 
 | Release | WIP branch |
 | ------: | :--------- |
-|  v0.9.0 | intake     |
-| v0.10.0 | judgement  |
 | v0.11.0 | knife      |
+| v0.12.0 | look       |
+| v0.13.0 | mind       |
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
 
@@ -72,11 +79,10 @@ npm test
 
 ### Memory leak tests
 
-Requires _valgrind_.
+Requires [Valgrind](http://valgrind.org/).
 
 ```sh
-cd sharp/test/leak
-./leak.sh
+npm run test-leak
 ```
 
 ## Finally

README.md

@@ -1,786 +1,30 @@
 # sharp
 
-* [Installation](https://github.com/lovell/sharp#installation)
-* [Usage examples](https://github.com/lovell/sharp#usage-examples)
-* [API](https://github.com/lovell/sharp#api)
-* [Contributing](https://github.com/lovell/sharp#contributing)
-* [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.
-
-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 formats from the filesystem via libmagick, libgraphicsmagick or [OpenSlide](http://openslide.org/) if present.
-
-Deep Zoom image pyramids can be generated, suitable for use with "slippy map" tile viewers like
-[OpenSeadragon](https://github.com/openseadragon/openseadragon) and [Leaflet](https://github.com/turban/Leaflet.Zoomify).
-
-Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
-
-Only small regions of uncompressed image data are held in memory and processed at a time, taking full advantage of multiple CPU cores and L1/L2/L3 cache. Resizing an image is typically 4x faster than using the quickest ImageMagick and GraphicsMagick settings.
-
-Huffman tables are optimised when generating JPEG output images without having to use separate command line tools like [jpegoptim](https://github.com/tjko/jpegoptim) and [jpegtran](http://jpegclub.org/jpegtran/). PNG filtering can be disabled, which for diagrams and line art often produces the same result as [pngcrush](http://pmt.sourceforge.net/pngcrush/).
-
-Everything remains non-blocking thanks to _libuv_, no child processes are spawned and Promises/A+ are supported.
-
-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](https://github.com/jcupitt).
-
-## Installation
-
-	npm install sharp
-
-### Prerequisites
-
-* Node.js v0.10+ or io.js
-* [libvips](https://github.com/jcupitt/libvips) v7.40.0+ (7.42.0+ recommended)
-* C++11 compatible compiler such as gcc 4.6+, clang 3.0+ or MSVC 2013
-
-To install the most suitable version of libvips on the following Operating Systems:
-
-* Mac OS
-  * Homebrew
-  * MacPorts
-* Debian Linux
-  * Debian 7, 8
-  * Ubuntu 12.04, 14.04, 14.10, 15.04
-  * Mint 13, 17
-* Red Hat Linux
-  * RHEL/Centos/Scientific 6, 7
-  * Fedora 21, 22
-  * Amazon Linux 2014.09
-* OpenSuse Linux
-  * OpenSuse 13.1, 13.2
-
-run the following as a user with `sudo` access:
-
-	curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
-
-or run the following as `root`:
-
-	curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | bash -
-
-The [preinstall.sh](https://github.com/lovell/sharp/blob/master/preinstall.sh) script requires `curl` and `pkg-config`.
-
-Add `--with-openslide` to enable OpenSlide support:
-
-	curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -s -- --with-openslide
-
-### Mac OS tips
-
-Manual install via homebrew:
-
-	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
-
-### Windows
-
-Requires x86 32-bit Node.js or io.js (use `iojs.exe` rather than `node.exe`).
-The WebP format is currently unsupported.
-
-1. Ensure the [node-gyp prerequisites](https://github.com/TooTallNate/node-gyp#installation) are met.
-2. [Download](http://www.vips.ecs.soton.ac.uk/supported/current/win32/) and unzip `vips-dev.x.y.z.zip`.
-3. Set the `VIPS_HOME` environment variable to the full path of the `vips-dev-x.y.z` directory.
-4. Add `vips-dev-x.y.z\bin` to `PATH`.
-
-Versions of MSVC more recent than 2013 may require the use of `npm install --arch=ia32 --msvs_version=2013`.
-
-### Heroku
-
-[Alessandro Tagliapietra](https://github.com/alex88) maintains an [Heroku buildpack for libvips](https://github.com/alex88/heroku-buildpack-vips) and its dependencies.
-
-### Docker
-
-[Marc Bachmann](https://github.com/marcbachmann) maintains a [Dockerfile for libvips](https://github.com/marcbachmann/dockerfile-libvips).
-
-	docker pull marcbachmann/libvips
-
-### Build tools
-
-* [gulp-responsive](https://www.npmjs.com/package/gulp-responsive)
-* [gulp-sharp](https://www.npmjs.com/package/gulp-sharp)
-* [grunt-sharp](https://www.npmjs.com/package/grunt-sharp)
-
-## Usage examples
-
-```javascript
-var sharp = require('sharp');
-```
-
-```javascript
-sharp('input.jpg').resize(300, 200).toFile('output.jpg', function(err) {
-  if (err) {
-    throw err;
-  }
-  // output.jpg is a 300 pixels wide and 200 pixels high image
-  // containing a scaled and cropped version of input.jpg
-});
-```
-
-```javascript
-var transformer = sharp()
-  .resize(300, 200)
-  .crop(sharp.gravity.north)
-  .on('error', function(err) {
-    console.log(err);
-  });
-// Read image data from readableStream, resize and write image data to writableStream
-readableStream.pipe(transformer).pipe(writableStream);
-```
-
-```javascript
-var image = sharp(inputJpg);
-image.metadata(function(err, metadata) {
-  image.resize(Math.floor(metadata.width / 2)).webp().toBuffer(function(err, outputBuffer, info) {
-    // outputBuffer contains a WebP image half the width and height of the original JPEG
-  });
-});
-```
-
-```javascript
-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('input.png')
-  .rotate(180)
-  .resize(300)
-  .flatten()
-  .background('#ff6600')
-  .sharpen()
-  .withMetadata()
-  .quality(90)
-  .webp()
-  .toBuffer()
-  .then(function(outputBuffer) {
-    // outputBuffer contains upside down, 300px wide, alpha channel flattened
-    // onto orange background, sharpened, with metadata, 90% quality WebP image
-    // data
-  });
-```
-
-```javascript
-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(input)
-  .extract(top, left, width, height)
-  .toFile(output);
-  // Extract a region of the input image, saving in the same format.
-```
-
-```javascript
-sharp(input)
-  .extract(topOffsetPre, leftOffsetPre, widthPre, heightPre)
-  .resize(width, height)
-  .extract(topOffsetPost, leftOffsetPost, widthPost, heightPost)
-  .toFile(output);
-  // Extract a region, resize, then extract from the resized image
-```
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 300)
-  .interpolateWith(sharp.interpolator.nohalo)
-  .background('white')
-  .embed()
-  .toFile('output.tiff')
-  .then(function() {
-    // output.tiff is a 200 pixels wide and 300 pixels high image
-    // containing a nohalo scaled version, embedded on a white canvas,
-    // of the image data in inputBuffer
-  });
-```
-
-```javascript
-sharp('input.gif')
-  .resize(200, 300)
-  .background({r: 0, g: 0, b: 0, a: 0})
-  .embed()
-  .toFormat(sharp.format.webp)
-  .toBuffer(function(err, outputBuffer) {
-    if (err) {
-      throw err;
-    }
-    // outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
-    // containing a scaled version, embedded on a transparent canvas, of input.gif
-  });
-```
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 200)
-  .max()
-  .toFormat('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
-  });
-```
-
-```javascript
-sharp('input.tiff').tile(256).toFile('output.dzi', function(err, info) {
-  // The output.dzi file is the XML format Deep Zoom definition
-  // The output_files directory contains 256x256 pixel tiles grouped by zoom level
-});
-```
-
-```javascript
-// Runtime discovery of available formats
-console.dir(sharp.format);
-```
-
-## API
-
-### Attributes
-
-#### format
-
-An Object containing nested boolean values
-representing the available input and output formats/methods,
-for example:
-
-```javascript
-{ jpeg: { id: 'jpeg',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: true, stream: true } },
-  png: { id: 'png',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: true, stream: true } },
-  webp: { id: 'webp',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: true, stream: true } },
-  tiff: { id: 'tiff',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: true, buffer: false, stream: false } },
-  magick: { id: 'magick',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: false, buffer: false, stream: false } },
-  raw: { id: 'raw',
-    input: { file: false, buffer: false, stream: false },
-    output: { file: false, buffer: true, stream: true } } }
-```
-
-#### queue
-
-An EventEmitter that emits a `change` event when a task is either:
-
-* queued, waiting for _libuv_ to provide a worker thread
-* complete
-
-```javascript
-sharp.queue.on('change', function(queueLength) {
-  console.log('Queue contains ' + queueLength + ' task(s)');
-});
-```
-
-### Input methods
-
-#### sharp([input])
-
-Constructor to which further methods are chained. `input`, if present, can be one of:
-
-* Buffer containing JPEG, PNG, WebP, GIF* or TIFF image data, or
-* String containing the filename of an image, with most major formats supported.
-
-The object returned implements the [stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
-
-JPEG, PNG, WebP, GIF* or TIFF 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.
-
-\* libvips 8.0.0+ is required for Buffer/Stream input of GIF and other `magick` formats.
-
-#### 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`, `magick` and `openslide`)
-* `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#L522)
-* `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
-* `hasProfile`: Boolean indicating the presence of an embedded ICC profile
-* `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
-* `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.
-
-#### limitInputPixels(pixels)
-
-Do not process input images where the number of pixels (width * height) exceeds this limit.
-
-`pixels` is the integral Number of pixels, with a value between 1 and the default 268402689 (0x3FFF * 0x3FFF).
-
-### Image transformation options
-
-#### resize(width, [height])
-
-Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
-
-`width` is the integral Number of pixels wide the resultant image should be, between 1 and 16383 (0x3FFF). Use `null` or `undefined` to auto-scale the width to match the height.
-
-`height` is the integral Number of pixels high the resultant image should be, between 1 and 16383. Use `null` or `undefined` to auto-scale the height to match the width.
-
-#### extract(top, left, width, height)
-
-Extract a region of the image. Can be used with or without a `resize` operation.
-
-`top` and `left` are the offset, in pixels, from the top-left corner.
-
-`width` and `height` are the dimensions of the extracted image.
-
-Use `extract` before `resize` for pre-resize extraction. Use `extract` after `resize` for post-resize extraction. Use `extract` before and after for both.
-
-#### crop([gravity])
-
-Crop the resized image to the exact size specified, the default behaviour.
-
-`gravity`, if present, is an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
-
-Possible values are `north`, `east`, `south`, `west`, `center` and `centre`. The default gravity is `center`/`centre`.
-
-#### max()
-
-Preserving aspect ratio,
-resize the image to be as large as possible
-while ensuring its dimensions are less than or equal to
-the `width` and `height` specified.
-
-Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
-
-#### min()
-
-Preserving aspect ratio,
-resize the image to be as small as possible
-while ensuring its dimensions are greater than or equal to
-the `width` and `height` specified.
-
-Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
-
-#### ignoreAspectRatio()
-
-Ignoring the aspect ratio of the input, stretch the image to the exact `width` and/or `height` provided via `resize`.
-
-#### background(rgba)
-
-Set the background for the `embed` and `flatten` operations.
-
-`rgba` is parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
-
-The alpha value is a float between `0` (transparent) and `1` (opaque).
-
-The default background is `{r: 0, g: 0, b: 0, a: 1}`, black without transparency.
-
-#### embed()
-
-Preserving aspect ratio, resize the image to the maximum `width` or `height` specified then embed on a background of the exact `width` and `height` specified.
-
-If the background contains an alpha value then WebP and PNG format output images will contain an alpha channel, even when the input image does not.
-
-#### flatten()
-
-Merge alpha transparency channel, if any, with `background`.
-
-#### rotate([angle])
-
-Rotate the output image by either an explicit angle or auto-orient based on the EXIF `Orientation` tag.
-
-`angle`, if present, is a Number with a value of `0`, `90`, `180` or `270`.
-
-Use this method without `angle` to determine the angle from EXIF data. Mirroring is supported and may infer the use of a `flip` operation.
-
-Method order is important when both rotating and extracting regions, for example `rotate(x).extract(y)` will produce a different result to `extract(y).rotate(x)`.
-
-#### flip()
-
-Flip the image about the vertical Y axis. This always occurs after rotation, if any.
-
-#### flop()
-
-Flop the image about the horizontal X axis. This always occurs after rotation, if any.
-
-#### 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".
-
-#### blur([sigma])
-
-When used without parameters, performs a fast, mild blur of the output image. This typically reduces performance by 10%.
-
-When a `sigma` is provided, performs a slower, more accurate Gaussian blur. This typically reduces performance by 25%.
-
-* `sigma`, if present, is a Number between 0.3 and 1000 representing the approximate blur radius in pixels.
-
-#### sharpen([radius], [flat], [jagged])
-
-When used without parameters, performs a fast, mild sharpen of the output image. This typically reduces performance by 10%.
-
-When a `radius` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space. Separate control over the level of sharpening in "flat" and "jagged" areas is available. This typically reduces performance by 50%.
-
-* `radius`, if present, is an integral Number representing the sharpen mask radius in pixels.
-* `flat`, if present, is a Number representing the level of sharpening to apply to "flat" areas, defaulting to a value of 1.0.
-* `jagged`, if present, is a Number representing the level of sharpening to apply to "jagged" areas, defaulting to a value of 2.0.
-
-#### interpolateWith(interpolator)
-
-Use the given interpolator for image resizing, where `interpolator` is an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.bicubic`.
-
-Possible interpolators, in order of performance, are:
-
-* `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.
-
-#### gamma([gamma])
-
-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`.
-
-`gamma`, if present, is a Number betweem 1 and 3. The default value is `2.2`, a suitable approximation for sRGB images.
-
-This can improve the perceived brightness of a resized image in non-linear colour spaces.
-
-JPEG input images will not take advantage of the shrink-on-load performance optimisation when applying a gamma correction.
-
-#### grayscale() / greyscale()
-
-Convert to 8-bit greyscale; 256 shades of grey.
-
-This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
-
-The output image will still be web-friendly sRGB and contain three (identical) channels.
-
-#### normalize() / normalise()
-
-Enhance output image contrast by stretching its luminance to cover the full dynamic range. This typically reduces performance by 30%.
-
-### 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.
-
-#### raw()
-
-_Requires libvips 7.42.0+_
-
-Provide raw, uncompressed uint8 (unsigned char) image data for Buffer and Stream based output.
-
-The number of channels depends on the input image and selected options.
-
-* 1 channel for images converted to `greyscale()`, with each byte representing one pixel.
-* 3 channels for colour images without alpha transparency, with bytes ordered \[red, green, blue, red, green, blue, etc.\]).
-* 4 channels for colour images with alpha transparency, with bytes ordered \[red, green, blue, alpha, red, green, blue, alpha, etc.\].
-
-#### toFormat(format)
-
-Convenience method for the above output format methods, where `format` is either:
-
-* an attribute of the `sharp.format` Object e.g. `sharp.format.jpeg`, or
-* a String containing `jpeg`, `png`, `webp` or `raw`.
-
-#### 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.
-
-#### 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()
-
-Include all metadata (EXIF, XMP, IPTC) from the input image in the output image. This will also convert to and add the latest web-friendly v2 sRGB ICC profile.
-
-The default behaviour is to strip all metadata and convert to the device-independent sRGB colour space.
-
-#### tile([size], [overlap])
-
-The size and overlap, in pixels, of square Deep Zoom image pyramid tiles.
-
-* `size` is an integral Number between 1 and 8192. The default value is 256 pixels.
-* `overlap` is an integral Number between 0 and 8192. The default value is 0 pixels.
-
-#### withoutChromaSubsampling()
-
-Disable the use of [chroma subsampling](http://en.wikipedia.org/wiki/Chroma_subsampling) with JPEG output (4:4:4).
-
-This can improve colour representation at higher quality settings (90+),
-but usually increases output file size and typically reduces performance by 25%.
-
-The default behaviour is to use chroma subsampling (4:2:0).
-
-#### trellisQuantisation() / trellisQuantization()
-
-_Requires libvips 8.0.0+ compiled against mozjpeg 3.0+_
-
-An advanced setting to apply the use of
-[trellis quantisation](http://en.wikipedia.org/wiki/Trellis_quantization) with JPEG output.
-Reduces file size and slightly increases relative quality at the cost of increased compression time.
-
-#### overshootDeringing()
-
-_Requires libvips 8.0.0+ compiled against mozjpeg 3.0+_
-
-An advanced setting to reduce the effects of
-[ringing](http://en.wikipedia.org/wiki/Ringing_%28signal%29) in JPEG output,
-in particular where black text appears on a white background (or vice versa).
-
-#### optimiseScans() / optimizeScans()
-
-_Requires libvips 8.0.0+ compiled against mozjpeg 3.0+_
-
-An advanced setting for progressive (interlace) JPEG output.
-Calculates which spectrum of DCT coefficients uses the fewest bits.
-Usually reduces file size at the cost of increased compression time.
-
-#### 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 0 and 9.
-
-#### withoutAdaptiveFiltering()
-
-_Requires libvips 7.42.0+_
-
-An advanced setting to disable adaptive row filtering for the lossless PNG output format.
-
-### Output methods
-
-#### toFile(filename, [callback])
-
-`filename` is a String containing the filename to write the image data to. The format is inferred from the extension, with JPEG, PNG, WebP, TIFF and DZI supported.
-
-`callback`, if present, is called with two arguments `(err, info)` where:
-
-* `err` contains an error message, if any.
-* `info` contains the output image `format`, `size` (bytes), `width` and `height`.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-#### toBuffer([callback])
-
-Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG and WebP are supported.
-
-`callback`, if present, gets three arguments `(err, buffer, info)` where:
-
-* `err` is an error message, if any.
-* `buffer` is the output image data.
-* `info` contains the output image `format`, `size` (bytes), `width` and `height`.
-
-A Promises/A+ promise is returned when `callback` is not provided.
-
-### Utility methods
-
-#### sharp.cache([memory], [items])
-
-If `memory` or `items` are provided, set the limits of _libvips'_ operation cache.
-
-* `memory` is the maximum memory in MB to use for this cache, with a default value of 100
-* `items` is the maximum number of operations to cache, with a default value of 500
-
-This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
-
-```javascript
-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 processing each image. 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 threads = sharp.concurrency(); // 4
-sharp.concurrency(2); // 2
-sharp.concurrency(0); // 4
-```
-
-The maximum number of images that can be processed in parallel is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
-
-#### 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 }
-```
-
-## Contributing
-
-A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md) covers reporting bugs, requesting features and submitting code changes.
-
-## Testing
-
-### Functional tests
-
-#### Coverage
+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.
 
 [![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
 
-#### Ubuntu 12.04
+### Documentation
 
-[![Ubuntu 12.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+Visit [sharp.dimens.io](http://sharp.dimens.io/) for
+complete installation instructions, API documentation,
+benchmark tests and a changelog.
 
-#### Centos 6.5
+### Contributing
 
-[![Centos 6.5 Build Status](https://snap-ci.com/lovell/sharp/branch/master/build_image)](https://snap-ci.com/lovell/sharp/branch/master)
+A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md)
+covers reporting bugs, requesting features and submitting code changes.
 
-#### Windows Server 2012
-
-[![Windows Server 2012 Build Status](https://ci.appveyor.com/api/projects/status/pgtul704nkhhg6sg)](https://ci.appveyor.com/project/lovell/sharp)
-
-### Benchmark tests
-
-```
-cd sharp/test/bench
-npm install
-npm test
-```
-
-Requires both _ImageMagick_ and _GraphicsMagick_:
-
-```
-brew install imagemagick
-brew install graphicsmagick
-```
-
-```
-sudo apt-get install -qq imagemagick graphicsmagick libmagickcore-dev
-```
-
-```
-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
-
-### Test environment
-
-* AWS EC2 [c3.xlarge](http://aws.amazon.com/ec2/instance-types/#Compute_Optimized)
-* Ubuntu 14.04
-* libvips 7.40.8
-* liborc 0.4.22
-
-### The contenders
-
-* [imagemagick-native](https://github.com/mash/node-imagemagick-native) v1.2.2 - Supports Buffers only
-* [imagemagick](https://github.com/yourdeveloper/node-imagemagick) v0.1.3 - Supports filesystem only and "has been unmaintained for a long time".
-* [gm](https://github.com/aheckmann/gm) v1.16.0 - Fully featured wrapper around GraphicsMagick.
-* sharp v0.6.2 - Caching within libvips disabled to ensure a fair comparison.
-
-### The task
-
-Decompress a 2725x2225 JPEG image, resize and crop to 720x480, then compress to JPEG.
-
-### Results
-
-| Module                | Input  | Output | Ops/sec | Speed-up |
-| :-------------------- | :----- | :----- | ------: | -------: |
-| imagemagick-native    | buffer | buffer |    1.58 |        1 |
-| imagemagick           | file   | file   |    6.23 |      3.9 |
-| gm                    | buffer | file   |    5.32 |      3.4 |
-| gm                    | buffer | buffer |    5.32 |      3.4 |
-| gm                    | file   | file   |    5.36 |      3.4 |
-| gm                    | file   | buffer |    5.36 |      3.4 |
-| sharp                 | buffer | file   |   22.05 |     14.0 |
-| sharp                 | buffer | buffer |   22.14 |     14.0 |
-| sharp                 | file   | file   |   21.79 |     13.8 |
-| sharp                 | file   | buffer |   21.90 |     13.9 |
-| sharp                 | stream | stream |   20.87 |     13.2 |
-| sharp +promise        | file   | buffer |   21.89 |     13.9 |
-| sharp +sharpen        | file   | buffer |   19.69 |     12.5 |
-| sharp +progressive    | file   | buffer |   16.93 |     10.7 |
-| sharp +sequentialRead | file   | buffer |   21.60 |     13.7 |
-
-You can expect greater performance with caching enabled (default) and using 8+ 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)
-* [Daniel Gasienica](https://github.com/gasi)
-* [Julian Walker](https://github.com/julianwa)
-* [Amit Pitaru](https://github.com/apitaru)
-* [Brandon Aaron](https://github.com/brandonaaron)
-* [Andreas Lind](https://github.com/papandreou)
-* [Maurus Cuelenaere](https://github.com/mcuelenaere)
-* [Linus Unneb<65>ck](https://github.com/LinusU)
-* [Victor Mateevitsi](https://github.com/mvictoras)
-* [Alaric Holloway](https://github.com/skedastik)
-* [Bernhard K. Weisshuhn](https://github.com/bkw)
-
-Thank you!
-
-## Licence
+### Licence
 
 Copyright 2013, 2014, 2015 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.
-You may obtain a copy of the License at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+You may obtain a copy of the License at
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

appveyor.yml

@@ -1,6 +1,7 @@
-os: Visual Studio 2014 CTP4
-platform: Win32
-configuration: Release
+os: Visual Studio 2015
+version: "{build}"
+build: off
+platform: x64
 environment:
   VIPS_VERSION_MAJOR_MINOR: 8.0
   VIPS_VERSION_PATCH: 2
@@ -10,7 +11,7 @@ environment:
     nodejs_exec: "node"
   - nodejs_version: "0.12"
     nodejs_exec: "node"
-  - nodejs_version: "1.0"
+  - nodejs_version: "2"
     nodejs_exec: "iojs"
 install:
   - ps: $env:VIPS_VERSION = "$env:VIPS_VERSION_MAJOR_MINOR.$env:VIPS_VERSION_PATCH"

binding.gyp

@@ -3,10 +3,11 @@
     'target_name': 'sharp',
     'sources': [
       'src/common.cc',
-      'src/utilities.cc',
       'src/metadata.cc',
-      'src/resize.cc',
-      'src/sharp.cc'
+      'src/operations.cc',
+      'src/pipeline.cc',
+      'src/sharp.cc',
+      'src/utilities.cc'
     ],
     'conditions': [
         ['OS=="win"', {
@@ -73,6 +74,15 @@
       'VCCLCompilerTool': {
         'ExceptionHandling': 1 # /EHsc
       }
-    }
+    },
+    'configurations': {
+      'Release': {
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'ExceptionHandling': 1,
+          }
+        }
+      }
+    },
   }]
 }

docs/api.md

@@ -0,0 +1,597 @@
+# API
+
+```javascript
+var sharp = require('sharp');
+```
+
+### Input
+
+#### sharp([input])
+
+Constructor to which further methods are chained. `input`, if present, can be one of:
+
+* Buffer containing JPEG, PNG, WebP, GIF* or TIFF image data, or
+* String containing the filename of an image, with most major formats supported.
+
+The object returned implements the
+[stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
+
+JPEG, PNG, WebP, GIF* or TIFF 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.
+
+\* libvips 8.0.0+ is required for Buffer/Stream input of GIF and other `magick` formats.
+
+```javascript
+sharp('input.jpg')
+  .resize(300, 200)
+  .toFile('output.jpg', function(err) {
+    // output.jpg is a 300 pixels wide and 200 pixels high image
+    // containing a scaled and cropped version of input.jpg
+  });
+```
+
+#### 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`, `magick` and `openslide`)
+* `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#L522)
+* `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+* `hasProfile`: Boolean indicating the presence of an embedded ICC profile
+* `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
+* `orientation`: Number value of the EXIF Orientation header, if present
+* `exif`: Buffer containing raw EXIF data, if present
+* `icc`: Buffer containing raw [ICC](https://www.npmjs.com/package/icc) profile data, if present
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+```javascript
+var image = sharp(inputJpg);
+image
+  .metadata()
+  .then(function(metadata) {
+    return image
+      .resize(Math.round(metadata.width / 2))
+      .webp()
+      .toBuffer();
+  })
+  .then(function(data) {
+    // data contains a WebP image half the width and height of the original JPEG
+  });
+```
+
+#### clone()
+
+Takes a "snapshot" of the instance, returning a new instance.
+Cloned instances inherit the input of their parent instance.
+
+This allows multiple output Streams
+and therefore multiple processing pipelines
+to share a single input Stream.
+
+```javascript
+var pipeline = sharp().rotate();
+pipeline.clone().resize(800, 600).pipe(firstWritableStream);
+pipeline.clone().extract(20, 20, 100, 100).pipe(secondWritableStream);
+readableStream.pipe(pipeline);
+// firstWritableStream receives auto-rotated, resized readableStream
+// secondWritableStream receives auto-rotated, extracted region of readableStream
+```
+
+#### 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.
+
+#### limitInputPixels(pixels)
+
+Do not process input images where the number of pixels (width * height) exceeds this limit.
+
+`pixels` is the integral Number of pixels, with a value between 1 and the default 268402689 (0x3FFF * 0x3FFF).
+
+### Resizing
+
+#### resize([width], [height])
+
+Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
+
+`width` is the integral Number of pixels wide the resultant image should be, between 1 and 16383 (0x3FFF). Use `null` or `undefined` to auto-scale the width to match the height.
+
+`height` is the integral Number of pixels high the resultant image should be, between 1 and 16383. Use `null` or `undefined` to auto-scale the height to match the width.
+
+#### crop([gravity])
+
+Crop the resized image to the exact size specified, the default behaviour.
+
+`gravity`, if present, is an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
+
+Possible values are `north`, `east`, `south`, `west`, `center` and `centre`. The default gravity is `center`/`centre`.
+
+```javascript
+var transformer = sharp()
+  .resize(300, 200)
+  .crop(sharp.gravity.north)
+  .on('error', function(err) {
+    console.log(err);
+  });
+// Read image data from readableStream, resize and write image data to writableStream
+readableStream.pipe(transformer).pipe(writableStream);
+```
+
+#### embed()
+
+Preserving aspect ratio, resize the image to the
+maximum `width` or `height` specified
+then embed on a background of the exact
+`width` and `height` specified.
+
+If the background contains an alpha value
+then WebP and PNG format output images will
+contain an alpha channel,
+even when the input image does not.
+
+```javascript
+sharp('input.gif')
+  .resize(200, 300)
+  .background({r: 0, g: 0, b: 0, a: 0})
+  .embed()
+  .toFormat(sharp.format.webp)
+  .toBuffer(function(err, outputBuffer) {
+    if (err) {
+      throw err;
+    }
+    // outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
+    // containing a scaled version, embedded on a transparent canvas, of input.gif
+  });
+```
+
+#### max()
+
+Preserving aspect ratio,
+resize the image to be as large as possible
+while ensuring its dimensions are less than or equal to
+the `width` and `height` specified.
+
+Both `width` and `height` must be provided via
+`resize` otherwise the behaviour will default to `crop`.
+
+```javascript
+sharp(inputBuffer)
+  .resize(200, 200)
+  .max()
+  .toFormat('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
+  });
+```
+
+#### min()
+
+Preserving aspect ratio,
+resize the image to be as small as possible
+while ensuring its dimensions are greater than or equal to
+the `width` and `height` specified.
+
+Both `width` and `height` must be provided via `resize` otherwise the behaviour will default to `crop`.
+
+#### 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*".
+
+#### ignoreAspectRatio()
+
+Ignoring the aspect ratio of the input, stretch the image to the exact `width` and/or `height` provided via `resize`.
+
+#### interpolateWith(interpolator)
+
+Use the given interpolator for image resizing, where `interpolator` is an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.bicubic`.
+
+Possible interpolators, in order of performance, are:
+
+* `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.
+
+```javascript
+sharp(inputBuffer)
+  .resize(200, 300)
+  .interpolateWith(sharp.interpolator.nohalo)
+  .background('white')
+  .embed()
+  .toFile('output.tiff')
+  .then(function() {
+    // output.tiff is a 200 pixels wide and 300 pixels high image
+    // containing a nohalo scaled version, embedded on a white canvas,
+    // of the image data in inputBuffer
+  });
+```
+
+### Operations
+
+#### extract(top, left, width, height)
+
+Extract a region of the image. Can be used with or without a `resize` operation.
+
+`top` and `left` are the offset, in pixels, from the top-left corner.
+
+`width` and `height` are the dimensions of the extracted image.
+
+Use `extract` before `resize` for pre-resize extraction. Use `extract` after `resize` for post-resize extraction. Use `extract` before and after for both.
+
+```javascript
+sharp(input)
+  .extract(top, left, width, height)
+  .toFile(output, function(err) {
+    // Extract a region of the input image, saving in the same format.
+  });
+```
+
+```javascript
+sharp(input)
+  .extract(topOffsetPre, leftOffsetPre, widthPre, heightPre)
+  .resize(width, height)
+  .extract(topOffsetPost, leftOffsetPost, widthPost, heightPost)
+  .toFile(output, function(err) {
+    // Extract a region, resize, then extract from the resized image
+  });
+```
+
+#### background(rgba)
+
+Set the background for the `embed` and `flatten` operations.
+
+`rgba` is parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
+
+The alpha value is a float between `0` (transparent) and `1` (opaque).
+
+The default background is `{r: 0, g: 0, b: 0, a: 1}`, black without transparency.
+
+#### flatten()
+
+Merge alpha transparency channel, if any, with `background`.
+
+#### rotate([angle])
+
+Rotate the output image by either an explicit angle or auto-orient based on the EXIF `Orientation` tag.
+
+`angle`, if present, is a Number with a value of `0`, `90`, `180` or `270`.
+
+Use this method without `angle` to determine the angle from EXIF data. Mirroring is supported and may infer the use of a `flip` operation.
+
+Method order is important when both rotating and extracting regions, for example `rotate(x).extract(y)` will produce a different result to `extract(y).rotate(x)`.
+
+The use of `rotate` implies the removal of the EXIF `Orientation` tag, if any.
+
+```javascript
+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);
+```
+
+#### flip()
+
+Flip the image about the vertical Y axis. This always occurs after rotation, if any.
+The use of `flip` implies the removal of the EXIF `Orientation` tag, if any.
+
+#### flop()
+
+Flop the image about the horizontal X axis. This always occurs after rotation, if any.
+The use of `flop` implies the removal of the EXIF `Orientation` tag, if any.
+
+#### blur([sigma])
+
+When used without parameters, performs a fast, mild blur of the output image. This typically reduces performance by 10%.
+
+When a `sigma` is provided, performs a slower, more accurate Gaussian blur. This typically reduces performance by 25%.
+
+* `sigma`, if present, is a Number between 0.3 and 1000 representing the approximate blur radius in pixels.
+
+#### sharpen([radius], [flat], [jagged])
+
+When used without parameters, performs a fast, mild sharpen of the output image. This typically reduces performance by 10%.
+
+When a `radius` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space. Separate control over the level of sharpening in "flat" and "jagged" areas is available. This typically reduces performance by 50%.
+
+* `radius`, if present, is an integral Number representing the sharpen mask radius in pixels.
+* `flat`, if present, is a Number representing the level of sharpening to apply to "flat" areas, defaulting to a value of 1.0.
+* `jagged`, if present, is a Number representing the level of sharpening to apply to "jagged" areas, defaulting to a value of 2.0.
+
+#### gamma([gamma])
+
+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`.
+
+`gamma`, if present, is a Number betweem 1 and 3. The default value is `2.2`, a suitable approximation for sRGB images.
+
+This can improve the perceived brightness of a resized image in non-linear colour spaces.
+
+JPEG input images will not take advantage of the shrink-on-load performance optimisation when applying a gamma correction.
+
+#### grayscale() / greyscale()
+
+Convert to 8-bit greyscale; 256 shades of grey.
+
+This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use `gamma()` with `greyscale()` for the best results.
+
+The output image will still be web-friendly sRGB and contain three (identical) channels.
+
+#### normalize() / normalise()
+
+Enhance output image contrast by stretching its luminance to cover the full dynamic range. This typically reduces performance by 30%.
+
+#### overlayWith(filename)
+
+_Experimental_
+
+Alpha composite `filename` over the processed (resized, extracted) image. The dimensions of the two images must match.
+
+* `filename` is a String containing the filename of an image with an alpha channel.
+
+```javascript
+sharp('input.png')
+  .rotate(180)
+  .resize(300)
+  .flatten()
+  .background('#ff6600')
+  .overlayWith('overlay.png')
+  .sharpen()
+  .withMetadata()
+  .quality(90)
+  .webp()
+  .toBuffer()
+  .then(function(outputBuffer) {
+    // outputBuffer contains upside down, 300px wide, alpha channel flattened
+    // onto orange background, composited with overlay.png, sharpened,
+    // with metadata, 90% quality WebP image data. Phew!
+  });
+```
+
+### Output
+
+#### 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, TIFF and DZI supported.
+
+`callback`, if present, is called with two arguments `(err, info)` where:
+
+* `err` contains an error message, if any.
+* `info` contains the output image `format`, `size` (bytes), `width` and `height`.
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+#### toBuffer([callback])
+
+Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG and WebP are supported.
+
+`callback`, if present, gets three arguments `(err, buffer, info)` where:
+
+* `err` is an error message, if any.
+* `buffer` is the output image data.
+* `info` contains the output image `format`, `size` (bytes), `width` and `height`.
+
+A Promises/A+ promise is returned when `callback` is not provided.
+
+#### jpeg()
+
+Use JPEG format for the output image.
+
+#### png()
+
+Use PNG format for the output image.
+
+#### webp()
+
+Use WebP format for the output image.
+
+#### raw()
+
+_Requires libvips 7.42.0+_
+
+Provide raw, uncompressed uint8 (unsigned char) image data for Buffer and Stream based output.
+
+The number of channels depends on the input image and selected options.
+
+* 1 channel for images converted to `greyscale()`, with each byte representing one pixel.
+* 3 channels for colour images without alpha transparency, with bytes ordered \[red, green, blue, red, green, blue, etc.\]).
+* 4 channels for colour images with alpha transparency, with bytes ordered \[red, green, blue, alpha, red, green, blue, alpha, etc.\].
+
+#### toFormat(format)
+
+Convenience method for the above output format methods, where `format` is either:
+
+* an attribute of the `sharp.format` Object e.g. `sharp.format.jpeg`, or
+* a String containing `jpeg`, `png`, `webp` or `raw`.
+
+#### 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.
+
+#### 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([metadata])
+
+Include all metadata (EXIF, XMP, IPTC) from the input image in the output image.
+This will also convert to and add the latest web-friendly v2 sRGB ICC profile.
+
+The optional `metadata` parameter, if present, is an Object with the attributes to update.
+New attributes cannot be inserted, only existing attributes updated.
+
+* `orientation` is an integral Number between 0 and 7, used to update the value of the EXIF `Orientation` tag.
+This has no effect if the input image does not have an EXIF `Orientation` tag.
+
+The default behaviour, when `withMetadata` is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
+
+#### tile([size], [overlap])
+
+The size and overlap, in pixels, of square Deep Zoom image pyramid tiles.
+
+* `size` is an integral Number between 1 and 8192. The default value is 256 pixels.
+* `overlap` is an integral Number between 0 and 8192. The default value is 0 pixels.
+
+```javascript
+sharp('input.tiff').tile(256).toFile('output.dzi', function(err, info) {
+  // The output.dzi file is the XML format Deep Zoom definition
+  // The output_files directory contains 256x256 pixel tiles grouped by zoom level
+});
+```
+
+#### withoutChromaSubsampling()
+
+Disable the use of [chroma subsampling](http://en.wikipedia.org/wiki/Chroma_subsampling) with JPEG output (4:4:4).
+
+This can improve colour representation at higher quality settings (90+),
+but usually increases output file size and typically reduces performance by 25%.
+
+The default behaviour is to use chroma subsampling (4:2:0).
+
+#### 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 0 and 9.
+
+#### withoutAdaptiveFiltering()
+
+_Requires libvips 7.42.0+_
+
+An advanced setting to disable adaptive row filtering for the lossless PNG output format.
+
+#### trellisQuantisation() / trellisQuantization()
+
+_Requires libvips 8.0.0+ compiled against mozjpeg 3.0+_
+
+An advanced setting to apply the use of
+[trellis quantisation](http://en.wikipedia.org/wiki/Trellis_quantization) with JPEG output.
+Reduces file size and slightly increases relative quality at the cost of increased compression time.
+
+#### overshootDeringing()
+
+_Requires libvips 8.0.0+ compiled against mozjpeg 3.0+_
+
+An advanced setting to reduce the effects of
+[ringing](http://en.wikipedia.org/wiki/Ringing_%28signal%29) in JPEG output,
+in particular where black text appears on a white background (or vice versa).
+
+#### optimiseScans() / optimizeScans()
+
+_Requires libvips 8.0.0+ compiled against mozjpeg 3.0+_
+
+An advanced setting for progressive (interlace) JPEG output.
+Calculates which spectrum of DCT coefficients uses the fewest bits.
+Usually reduces file size at the cost of increased compression time.
+
+### Attributes
+
+#### format
+
+An Object containing nested boolean values
+representing the available input and output formats/methods,
+for example:
+
+```javascript
+> console.dir(sharp.format);
+
+{ jpeg: { id: 'jpeg',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: true, stream: true } },
+  png: { id: 'png',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: true, stream: true } },
+  webp: { id: 'webp',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: true, stream: true } },
+  tiff: { id: 'tiff',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: true, buffer: false, stream: false } },
+  magick: { id: 'magick',
+    input: { file: true, buffer: true, stream: true },
+    output: { file: false, buffer: false, stream: false } },
+  raw: { id: 'raw',
+    input: { file: false, buffer: false, stream: false },
+    output: { file: false, buffer: true, stream: true } } }
+```
+
+#### queue
+
+An EventEmitter that emits a `change` event when a task is either:
+
+* queued, waiting for _libuv_ to provide a worker thread
+* complete
+
+```javascript
+sharp.queue.on('change', function(queueLength) {
+  console.log('Queue contains ' + queueLength + ' task(s)');
+});
+```
+
+### Utilities
+
+#### sharp.cache([memory], [items])
+
+If `memory` or `items` are provided, set the limits of _libvips'_ operation cache.
+
+* `memory` is the maximum memory in MB to use for this cache, with a default value of 100
+* `items` is the maximum number of operations to cache, with a default value of 500
+
+This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
+
+```javascript
+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 processing each image. 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 threads = sharp.concurrency(); // 4
+sharp.concurrency(2); // 2
+sharp.concurrency(0); // 4
+```
+
+The maximum number of images that can be processed in parallel is limited by libuv's `UV_THREADPOOL_SIZE` environment variable.
+
+#### 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 }
+```

docs/changelog.md

@@ -0,0 +1,73 @@
+# Changelog
+
+### v0.11 - "*knife*"
+
+#### v0.11.1 - 12<sup>th</sup> August 2015
+
+* Silence MSVC warning: "C4530: C++ exception handler used, but unwind semantics are not enabled".
+  [#244](https://github.com/lovell/sharp/pull/244)
+  [@TheThing](https://github.com/TheThing)
+
+* Suppress gamma correction for input image with alpha transparency.
+  [#249](https://github.com/lovell/sharp/issues/249)
+  [@compeak](https://github.com/compeak)
+
+#### v0.11.0 - 15<sup>th</sup> July 2015
+
+* Allow alpha transparency compositing via new `overlayWith` method.
+  [#97](https://github.com/lovell/sharp/issues/97)
+  [@gasi](https://github.com/gasi)
+
+* Expose raw ICC profile data as a Buffer when using `metadata`.
+  [#129](https://github.com/lovell/sharp/issues/129)
+  [@homerjam](https://github.com/homerjam)
+
+* Allow image header updates via a parameter passed to existing `withMetadata` method.
+  Provide initial support for EXIF `Orientation` tag,
+  which if present is now removed when using `rotate`, `flip` or `flop`.
+  [#189](https://github.com/lovell/sharp/issues/189)
+  [@h2non](https://github.com/h2non)
+
+* Tighten constructor parameter checks.
+  [#221](https://github.com/lovell/sharp/issues/221)
+  [@mikemorris](https://github.com/mikemorris)
+
+* Allow one input Stream to be shared with two or more output Streams via new `clone` method.
+  [#235](https://github.com/lovell/sharp/issues/235)
+  [@jaubourg](https://github.com/jaubourg)
+
+* Use `round` instead of `floor` when auto-scaling dimensions to avoid floating-point rounding errors.
+  [#238](https://github.com/lovell/sharp/issues/238)
+  [@richardadjogah](https://github.com/richardadjogah)
+
+### v0.10 - "*judgment*"
+
+#### v0.10.1 - 1<sup>st</sup> June 2015
+
+* Allow embed of image with alpha transparency onto non-transparent background.
+  [#204](https://github.com/lovell/sharp/issues/204)
+  [@mikemliu](https://github.com/mikemliu)
+
+* Include C standard library for `atoi` as Xcode 6.3 appears to no longer do this.
+  [#228](https://github.com/lovell/sharp/issues/228)
+  [@doggan](https://github.com/doggan)
+
+#### v0.10.0 - 23<sup>rd</sup> April 2015
+
+* Add support for Windows (x86).
+  [#19](https://github.com/lovell/sharp/issues/19)
+  [@DullReferenceException](https://github.com/DullReferenceException)
+  [@itsananderson](https://github.com/itsananderson)
+
+* Add support for Openslide input and DeepZoom output.
+  [#146](https://github.com/lovell/sharp/issues/146)
+  [@mvictoras](https://github.com/mvictoras)
+
+* Allow arbitrary aspect ratios when resizing images via new `ignoreAspectRatio` method.
+  [#192](https://github.com/lovell/sharp/issues/192)
+  [@skedastik](https://github.com/skedastik)
+
+* Enhance output image contrast by stretching its luminance to cover the full dynamic range via new `normalize` method.
+  [#194](https://github.com/lovell/sharp/issues/194)
+  [@bkw](https://github.com/bkw)
+  [@codingforce](https://github.com/codingforce)

docs/index.md

@@ -0,0 +1,103 @@
+# sharp
+
+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.
+
+Resizing an image is typically 4x faster than using
+the quickest ImageMagick and GraphicsMagick settings.
+
+[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+
+### Formats
+
+This module supports reading JPEG, PNG, WebP, TIFF, OpenSlide,
+GIF and other libmagick-supported formats.
+
+Output images can be in JPEG, PNG and WebP formats as well as uncompressed raw pixel data.
+
+Streams, Buffer objects and the filesystem can be used for input and output.
+
+A single input Stream can be split into multiple processing pipelines and output Streams.
+
+Deep Zoom image pyramids can be generated,
+suitable for use with "slippy map" tile viewers like
+[OpenSeadragon](https://github.com/openseadragon/openseadragon)
+and [Leaflet](https://github.com/turban/Leaflet.Zoomify).
+
+### Features
+
+As well as image resizing, operations such as
+rotation, extraction, compositing and gamma correction are available.
+
+Colour spaces, embedded ICC profiles and alpha transparency channels
+are all handled correctly.
+
+### Fast
+
+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).
+
+Only small regions of uncompressed image data
+are held in memory and processed at a time,
+taking full advantage of multiple CPU cores and L1/L2/L3 cache.
+
+Everything remains non-blocking thanks to _libuv_,
+no child processes are spawned and Promises/A+ are supported.
+
+### Optimal
+
+Huffman tables are optimised when generating JPEG output images
+without having to use separate command line tools like
+[jpegoptim](https://github.com/tjko/jpegoptim) and
+[jpegtran](http://jpegclub.org/jpegtran/).
+
+PNG filtering can be disabled,
+which for diagrams and line art often produces the same result
+as [pngcrush](http://pmt.sourceforge.net/pngcrush/).
+
+### Contributing
+
+A [guide for contributors](https://github.com/lovell/sharp/blob/master/CONTRIBUTING.md)
+covers reporting bugs, requesting features and submitting code changes.
+
+### Credits
+
+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)
+* [Daniel Gasienica](https://github.com/gasi)
+* [Julian Walker](https://github.com/julianwa)
+* [Amit Pitaru](https://github.com/apitaru)
+* [Brandon Aaron](https://github.com/brandonaaron)
+* [Andreas Lind](https://github.com/papandreou)
+* [Maurus Cuelenaere](https://github.com/mcuelenaere)
+* [Linus Unnebäck](https://github.com/LinusU)
+* [Victor Mateevitsi](https://github.com/mvictoras)
+* [Alaric Holloway](https://github.com/skedastik)
+* [Bernhard K. Weisshuhn](https://github.com/bkw)
+
+Thank you!
+
+### Licence
+
+Copyright 2013, 2014, 2015 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.
+You may obtain a copy of the License at
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

docs/install.md

@@ -0,0 +1,123 @@
+# Installation
+
+```sh
+npm install sharp
+```
+
+### Prerequisites
+
+* Node.js v0.10+ or io.js
+* [libvips](https://github.com/jcupitt/libvips) v7.40.0+ (7.42.0+ recommended)
+* C++11 compatible compiler such as gcc 4.6+, clang 3.0+ or MSVC 2013
+
+### Linux
+
+[![Ubuntu 12.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+[![Centos 6.5 Build Status](https://snap-ci.com/lovell/sharp/branch/master/build_image)](https://snap-ci.com/lovell/sharp/branch/master)
+
+For a system-wide installation of the most suitable version of
+libvips and its dependencies on the following Operating Systems:
+
+* Debian 7, 8
+* Ubuntu 12.04, 14.04, 14.10, 15.04
+* Mint 13, 17
+* RHEL/Centos/Scientific 6, 7
+* Fedora 21, 22
+* Amazon Linux 2014.09, 2015.03
+* OpenSuse 13
+
+run the following as a user with `sudo` access:
+
+```sh
+curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
+```
+
+or run the following as `root`:
+
+```sh
+curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | bash -
+```
+
+The [preinstall.sh](https://github.com/lovell/sharp/blob/master/preinstall.sh) script requires `curl` and `pkg-config`.
+
+Add `--with-openslide` to enable OpenSlide support:
+
+```sh
+curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -s -- --with-openslide
+```
+
+#### Ubuntu LTS
+
+libvips v7.40.6 is available via a PPA.
+
+##### 12.04
+
+```sh
+sudo add-apt-repository -y ppa:lovell/precise-backport-vips
+sudo apt-get update
+sudo apt-get install -y libvips-dev libgsf-1-dev
+```
+
+##### 14.04
+
+```sh
+sudo add-apt-repository -y ppa:lovell/trusty-backport-vips
+sudo apt-get update
+sudo apt-get install -y libvips-dev libgsf-1-dev
+```
+
+### Mac OS
+
+[![OS X 10.9.5 Build Status](https://travis-ci.org/lovell/sharp-osx-ci.png?branch=master)](https://travis-ci.org/lovell/sharp-osx-ci)
+
+Install libvips via homebrew:
+
+```sh
+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`.
+
+### Windows
+
+[![Windows Server 2012 Build Status](https://ci.appveyor.com/api/projects/status/pgtul704nkhhg6sg)](https://ci.appveyor.com/project/lovell/sharp)
+
+Requires x86 32-bit Node.js or io.js (use `iojs.exe` rather than `node.exe`).
+
+The WebP format is currently unsupported.
+
+1. Ensure the [node-gyp prerequisites](https://github.com/TooTallNate/node-gyp#installation) are met.
+2. [Download](http://www.vips.ecs.soton.ac.uk/supported/current/win32/) and unzip `vips-dev.x.y.z.zip`.
+3. Set the `VIPS_HOME` environment variable to the full path of the `vips-dev-x.y.z` directory.
+4. Add `vips-dev-x.y.z\bin` to `PATH`.
+
+Versions of MSVC more recent than 2013 may require the use of `npm install --arch=ia32 --msvs_version=2013`.
+
+### Heroku
+
+[Alessandro Tagliapietra](https://github.com/alex88) maintains an
+[Heroku buildpack for libvips](https://github.com/alex88/heroku-buildpack-vips)
+and its dependencies.
+
+### Docker
+
+[Marc Bachmann](https://github.com/marcbachmann) maintains a
+[Dockerfile for libvips](https://github.com/marcbachmann/dockerfile-libvips).
+
+```sh
+docker pull marcbachmann/libvips
+```
+
+### Build tools
+
+* [gulp-responsive](https://www.npmjs.com/package/gulp-responsive)
+* [gulp-sharp](https://www.npmjs.com/package/gulp-sharp)
+* [grunt-sharp](https://www.npmjs.com/package/grunt-sharp)

docs/performance.md

@@ -0,0 +1,63 @@
+# Performance
+
+### Test environment
+
+* AWS EC2 [c4.xlarge](http://aws.amazon.com/ec2/instance-types/#c4)
+* Ubuntu 15.04
+* Node.js 0.12.7
+* libvips 8.0.2
+* liborc 0.4.22
+
+### The contenders
+
+* [lwip](https://www.npmjs.com/package/lwip) 0.0.7 - Wrapper around CImg, compiles dependencies from source
+* [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) git@45d4e2e - Wrapper around libmagick++, supports Buffers only.
+* [imagemagick](https://www.npmjs.com/package/imagemagick) 0.1.3 - Supports filesystem only and "*has been unmaintained for a long time*".
+* [gm](https://www.npmjs.com/package/gm) 1.18.1 - Fully featured wrapper around GraphicsMagick's `convert` command line utility.
+* sharp 0.11.0 - Caching within libvips disabled to ensure a fair comparison.
+
+### The task
+
+Decompress a 2725x2225 JPEG image, resize to 720x480 using bilinear interpolation, then compress to JPEG.
+
+### Results
+
+| Module             | Input  | Output | Ops/sec | Speed-up |
+| :----------------- | :----- | :----- | ------: | -------: |
+| lwip               | file   | file   |    1.75 |        1 |
+| lwip               | buffer | buffer |    2.21 |      1.3 |
+| imagemagick-native | buffer | buffer |    7.13 |      4.1 |
+| gm                 | buffer | buffer |    7.27 |      4.2 |
+| gm                 | file   | file   |    7.33 |      4.2 |
+| imagemagick        | file   | file   |   10.04 |      5.7 |
+| sharp              | stream | stream |   23.12 |     13.2 |
+| sharp              | file   | file   |   24.43 |     14.0 |
+| sharp              | file   | buffer |   24.55 |     14.0 |
+| sharp              | buffer | file   |   24.86 |     14.2 |
+| sharp              | buffer | buffer |   24.92 |     14.2 |
+
+Greater performance can be expected with caching enabled (default) and using 8+ core machines.
+
+The I/O limits of the relevant (de)compression library will generally determine maximum throughput.
+
+### Benchmark test prerequisites
+
+Requires both _ImageMagick_ and _GraphicsMagick_:
+
+```sh
+brew install imagemagick
+brew install graphicsmagick
+```
+
+```sh
+sudo apt-get install imagemagick graphicsmagick libmagick++-dev
+```
+
+### Running the benchmark test
+
+```sh
+git clone https://github.com/lovell/sharp.git
+cd sharp/test/bench
+npm install
+npm test
+```

index.js

@@ -60,6 +60,8 @@ var Sharp = function(input) {
     gamma: 0,
     greyscale: false,
     normalize: 0,
+    // overlay
+    overlayPath: '',
     // output options
     output: '__input',
     progressive: false,
@@ -72,6 +74,7 @@ var Sharp = function(input) {
     optimiseScans: false,
     streamOut: false,
     withMetadata: false,
+    withMetadataOrientation: -1,
     tileSize: 256,
     tileOverlap: 0,
     // Function to notify of queue length changes
@@ -85,9 +88,11 @@ var Sharp = function(input) {
   } else if (typeof input === 'object' && input instanceof Buffer) {
     // input=buffer
     this.options.bufferIn = input;
-  } else {
+  } else if (typeof input === 'undefined') {
     // input=stream
     this.options.streamIn = true;
+  } else {
+    throw new Error('Unsupported input ' + typeof input);
   }
   return this;
 };
@@ -203,6 +208,17 @@ Sharp.prototype.flatten = function(flatten) {
   return this;
 };
 
+Sharp.prototype.overlayWith = function(overlayPath) {
+  if (typeof overlayPath !== 'string') {
+    throw new Error('The overlay path must be a string');
+  }
+  if (overlayPath === '') {
+    throw new Error('The overlay path cannot be empty');
+  }
+  this.options.overlayPath = overlayPath;
+  return this;
+};
+
 /*
   Rotate output image by 0, 90, 180 or 270 degrees
   Auto-rotation based on the EXIF Orientation tag is represented by an angle of -1
@@ -381,7 +397,7 @@ Sharp.prototype.sequentialRead = function(sequentialRead) {
 };
 
 Sharp.prototype.quality = function(quality) {
-  if (!Number.isNaN(quality) && quality >= 1 && quality <= 100) {
+  if (!Number.isNaN(quality) && quality >= 1 && quality <= 100 && quality % 1 === 0) {
     this.options.quality = quality;
   } else {
     throw new Error('Invalid quality (1 to 100) ' + quality);
@@ -464,9 +480,26 @@ Sharp.prototype.optimizeScans = Sharp.prototype.optimiseScans;
 
 /*
   Include all metadata (EXIF, XMP, IPTC) from the input image in the output image
+  Optionally provide an Object with attributes to update:
+    orientation: numeric value for EXIF Orientation tag
 */
 Sharp.prototype.withMetadata = function(withMetadata) {
   this.options.withMetadata = (typeof withMetadata === 'boolean') ? withMetadata : true;
+  if (typeof withMetadata === 'object') {
+    if ('orientation' in withMetadata) {
+      if (
+        typeof withMetadata.orientation === 'number' &&
+        !Number.isNaN(withMetadata.orientation) &&
+        withMetadata.orientation % 1 === 0 &&
+        withMetadata.orientation >=0 &&
+        withMetadata.orientation <= 7
+      ) {
+        this.options.withMetadataOrientation = withMetadata.orientation;
+      } else {
+        throw new Error('Invalid orientation (0 to 7) ' + withMetadata.orientation);
+      }
+    }
+  }
   return this;
 };
 
@@ -552,7 +585,7 @@ Sharp.prototype.toFile = function(output, callback) {
       }
     } else {
       this.options.output = output;
-      return this._sharp(callback);
+      return this._pipeline(callback);
     }
   }
   return this;
@@ -562,7 +595,7 @@ Sharp.prototype.toFile = function(output, callback) {
   Write output to a Buffer
 */
 Sharp.prototype.toBuffer = function(callback) {
-  return this._sharp(callback);
+  return this._pipeline(callback);
 };
 
 /*
@@ -625,7 +658,7 @@ Sharp.prototype.toFormat = function(format) {
 Sharp.prototype._read = function() {
   if (!this.options.streamOut) {
     this.options.streamOut = true;
-    this._sharp();
+    this._pipeline();
   }
 };
 
@@ -633,18 +666,18 @@ Sharp.prototype._read = function() {
   Invoke the C++ image processing pipeline
   Supports callback, stream and promise variants
 */
-Sharp.prototype._sharp = function(callback) {
+Sharp.prototype._pipeline = function(callback) {
   var that = this;
   if (typeof callback === 'function') {
     // output=file/buffer
     if (this.options.streamIn) {
       // output=file/buffer, input=stream
       this.on('finish', function() {
-        sharp.resize(that.options, callback);
+        sharp.pipeline(that.options, callback);
       });
     } else {
       // output=file/buffer, input=file/buffer
-      sharp.resize(this.options, callback);
+      sharp.pipeline(this.options, callback);
     }
     return this;
   } else if (this.options.streamOut) {
@@ -652,9 +685,9 @@ Sharp.prototype._sharp = function(callback) {
     if (this.options.streamIn) {
       // output=stream, input=stream
       this.on('finish', function() {
-        sharp.resize(that.options, function(err, data) {
+        sharp.pipeline(that.options, function(err, data) {
           if (err) {
-            that.emit('error', new Error(err));
+            that.emit('error', err);
           } else {
             that.push(data);
           }
@@ -663,9 +696,9 @@ Sharp.prototype._sharp = function(callback) {
       });
     } else {
       // output=stream, input=file/buffer
-      sharp.resize(this.options, function(err, data) {
+      sharp.pipeline(this.options, function(err, data) {
         if (err) {
-          that.emit('error', new Error(err));
+          that.emit('error', err);
         } else {
           that.push(data);
         }
@@ -679,7 +712,7 @@ Sharp.prototype._sharp = function(callback) {
       // output=promise, input=stream
       return new BluebirdPromise(function(resolve, reject) {
         that.on('finish', function() {
-          sharp.resize(that.options, function(err, data) {
+          sharp.pipeline(that.options, function(err, data) {
             if (err) {
               reject(err);
             } else {
@@ -691,7 +724,7 @@ Sharp.prototype._sharp = function(callback) {
     } else {
       // output=promise, input=file/buffer
       return new BluebirdPromise(function(resolve, reject) {
-        sharp.resize(that.options, function(err, data) {
+        sharp.pipeline(that.options, function(err, data) {
           if (err) {
             reject(err);
           } else {
@@ -722,22 +755,22 @@ Sharp.prototype.metadata = function(callback) {
     if (this.options.streamIn) {
       return new BluebirdPromise(function(resolve, reject) {
         that.on('finish', function() {
-          sharp.metadata(that.options, function(err, data) {
+          sharp.metadata(that.options, function(err, metadata) {
             if (err) {
               reject(err);
             } else {
-              resolve(data);
+              resolve(metadata);
             }
           });
         });
       });
     } else {
       return new BluebirdPromise(function(resolve, reject) {
-        sharp.metadata(that.options, function(err, data) {
+        sharp.metadata(that.options, function(err, metadata) {
           if (err) {
             reject(err);
           } else {
-            resolve(data);
+            resolve(metadata);
           }
         });
       });
@@ -745,6 +778,24 @@ Sharp.prototype.metadata = function(callback) {
   }
 };
 
+/*
+  Clone new instance using existing options.
+  Cloned instances share the same input.
+*/
+Sharp.prototype.clone = function() {
+  // Clone existing options
+  var clone = new Sharp();
+  util._extend(clone.options, this.options);
+  clone.streamIn = false;
+  // Pass 'finish' event to clone for Stream-based input
+  this.on('finish', function() {
+    // Clone inherits input data
+    clone.options.bufferIn = this.options.bufferIn;
+    clone.emit('finish');
+  });
+  return clone;
+};
+
 /*
   Get and set cache memory and item limits
 */

mkdocs.yml

@@ -0,0 +1,17 @@
+site_name: sharp
+site_url: http://sharp.dimens.io/
+repo_url: https://github.com/lovell/sharp
+site_description: The fastest Node.js module for resizing JPEG, PNG, WebP and TIFF images. Uses the libvips library.
+copyright: <a href="https://dimens.io/">dimens.io</a>
+google_analytics: ['UA-13034748-12', 'sharp.dimens.io']
+theme: readthedocs
+markdown_extensions:
+  - toc:
+      permalink: True
+dev_addr: 0.0.0.0:10101
+pages:
+  - Home: index.md
+  - Installation: install.md
+  - API: api.md
+  - Performance: performance.md
+  - Changelog: changelog.md

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharp",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "contributors": [
     "Pierre Inglebert <pierre.inglebert@gmail.com>",
@@ -20,9 +20,12 @@
   ],
   "description": "High performance Node.js module to resize JPEG, PNG, WebP and TIFF images using the libvips library",
   "scripts": {
+    "clean": "rm -rf test/fixtures/output.*",
     "test": "VIPS_WARNING=0 node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- --slow=5000 --timeout=20000 ./test/unit/*.js",
-    "test-win32-node": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=20000 ./test/unit/*.js",
-    "test-win32-iojs": "iojs ./node_modules/mocha/bin/mocha --slow=5000 --timeout=20000 ./test/unit/*.js"
+    "test-clean": "npm run clean && npm install && npm test",
+    "test-leak": "cd test/leak; ./leak.sh; cd - > /dev/null",
+    "test-win32-node": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=30000 ./test/unit/*.js",
+    "test-win32-iojs": "iojs ./node_modules/mocha/bin/mocha --slow=5000 --timeout=30000 ./test/unit/*.js"
   },
   "main": "index.js",
   "repository": {
@@ -42,19 +45,21 @@
     "vips"
   ],
   "dependencies": {
-    "bluebird": "^2.9.27",
-    "color": "^0.8.0",
+    "bluebird": "^2.9.33",
+    "color": "^0.10.1",
     "nan": "^1.8.4",
-    "semver": "^4.3.6"
+    "semver": "^5.0.1"
   },
   "devDependencies": {
-    "async": "^1.1.0",
+    "async": "^1.4.2",
     "coveralls": "^2.11.2",
-    "istanbul": "^0.3.14",
+    "exif-reader": "1.0.0",
+    "icc": "^0.0.2",
+    "istanbul": "^0.3.17",
     "mocha": "^2.2.5",
     "mocha-jshint": "^2.2.3",
     "node-cpplint": "^0.4.0",
-    "rimraf": "^2.3.4"
+    "rimraf": "^2.4.1"
   },
   "license": "Apache-2.0",
   "engines": {

preinstall.sh

@@ -2,7 +2,6 @@
 
 # Ensures libvips is installed and attempts to install it if not
 # Currently supports:
-# * Mac OS
 # * Debian Linux
 #   * Debian 7, 8
 #   * Ubuntu 12.04, 14.04, 14.10, 15.04
@@ -10,7 +9,7 @@
 # * Red Hat Linux
 #   * RHEL/Centos/Scientific 6, 7
 #   * Fedora 21, 22
-#   * Amazon Linux 2014.09
+#   * Amazon Linux 2014.09, 2015.03
 
 vips_version_minimum=7.40.0
 vips_version_latest_major_minor=8.0
@@ -55,8 +54,7 @@ sorry() {
   exit 1
 }
 
-pkg_config_path_homebrew=`which brew >/dev/null 2>&1 && eval $(brew --env) && echo $PKG_CONFIG_LIBDIR || true`
-pkg_config_path="$pkg_config_path_homebrew:$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig"
+pkg_config_path="$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig"
 
 check_if_library_exists() {
   PKG_CONFIG_PATH=$pkg_config_path pkg-config --exists $1
@@ -122,243 +120,205 @@ fi
 # OS-specific installations of libopenslide follows
 # Either openslide does not exist, or vips is installed without openslide support
 if [ $enable_openslide -eq 1 ] && [ -z $vips_with_openslide ] && [ $openslide_exists -eq 0 ]; then
-  case $(uname -s) in
-    *[Dd]arwin*)
-      # Mac OS
-      echo "Detected Mac OS"
-      if type "brew" > /dev/null; then
-        echo "Installing libopenslide via homebrew"
-        brew install openslide
-      elif type "port" > /dev/null; then
-        echo "Installing libopenslide via MacPorts"
-        port install openslide
-      else
-        sorry "openslide" "Mac OS without homebrew or MacPorts"
-      fi
+  if [ -f /etc/debian_version ]; then
+    # Debian Linux
+    DISTRO=$(lsb_release -c -s)
+    echo "Detected Debian Linux '$DISTRO'"
+    case "$DISTRO" in
+      jessie|vivid)
+        # Debian 8, Ubuntu 15
+        echo "Installing libopenslide via apt-get"
+        apt-get install -y libopenslide-dev
+        ;;
+      trusty|utopic|qiana|rebecca|rafaela)
+        # Ubuntu 14, Mint 17
+        echo "Installing libopenslide dependencies via apt-get"
+        apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
+        install_libopenslide_from_source
+        ;;
+      precise|wheezy|maya)
+        # Debian 7, Ubuntu 12.04, Mint 13
+        echo "Installing libopenslide dependencies via apt-get"
+        apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
+        install_libopenslide_from_source
+        ;;
+      *)
+        # Unsupported Debian-based OS
+        sorry "openslide" "Debian-based $DISTRO"
+        ;;
+    esac
+  elif [ -f /etc/redhat-release ]; then
+    # Red Hat Linux
+    RELEASE=$(cat /etc/redhat-release)
+    echo "Detected Red Hat Linux '$RELEASE'"
+    case $RELEASE in
+      "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
+        # RHEL/CentOS 7
+        echo "Installing libopenslide dependencies via yum"
+        yum groupinstall -y "Development Tools"
+        yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel
+        install_libopenslide_from_source "--prefix=/usr"
+        ;;
+      "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
+        # RHEL/CentOS 6
+        echo "Installing libopenslide dependencies via yum"
+        yum groupinstall -y "Development Tools"
+        yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel
+        install_libopenslide_from_source "--prefix=/usr"
+        ;;
+      "Fedora release 21 "*|"Fedora release 22 "*)
+        # Fedora 21, 22
+        echo "Installing libopenslide via yum"
+        yum install -y openslide-devel
+        ;;
+      *)
+        # Unsupported RHEL-based OS
+        sorry "openslide" "$RELEASE"
+        ;;
+    esac
+  elif [ -f /etc/os-release ]; then
+    RELEASE=$(cat /etc/os-release | grep VERSION)
+    echo "Detected OpenSuse Linux '$RELEASE'"
+    case $RELEASE in
+      *"13.2"*)
+      echo "Installing libopenslide via zypper"
+      zypper --gpg-auto-import-keys install -y libopenslide-devel
       ;;
-    *)
-      if [ -f /etc/debian_version ]; then
-        # Debian Linux
-        DISTRO=$(lsb_release -c -s)
-        echo "Detected Debian Linux '$DISTRO'"
-        case "$DISTRO" in
-          jessie|vivid)
-            # Debian 8, Ubuntu 15
-            echo "Installing libopenslide via apt-get"
-            apt-get install -y libopenslide-dev
-            ;;
-          trusty|utopic|qiana|rebecca)
-            # Ubuntu 14, Mint 17
-            echo "Installing libopenslide dependencies via apt-get"
-            apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
-            install_libopenslide_from_source
-            ;;
-          precise|wheezy|maya)
-            # Debian 7, Ubuntu 12.04, Mint 13
-            echo "Installing libopenslide dependencies via apt-get"
-            apt-get install -y automake build-essential curl zlib1g-dev libopenjpeg-dev libpng12-dev libjpeg-dev libtiff5-dev libgdk-pixbuf2.0-dev libxml2-dev libsqlite3-dev libcairo2-dev libglib2.0-dev sqlite3 libsqlite3-dev
-            install_libopenslide_from_source
-            ;;
-          *)
-            # Unsupported Debian-based OS
-            sorry "openslide" "Debian-based $DISTRO"
-            ;;
-        esac
-      elif [ -f /etc/redhat-release ]; then
-        # Red Hat Linux
-        RELEASE=$(cat /etc/redhat-release)
-        echo "Detected Red Hat Linux '$RELEASE'"
-        case $RELEASE in
-          "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
-            # RHEL/CentOS 7
-            echo "Installing libopenslide dependencies via yum"
-            yum groupinstall -y "Development Tools"
-            yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel
-            install_libopenslide_from_source "--prefix=/usr"
-            ;;
-          "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
-            # RHEL/CentOS 6
-            echo "Installing libopenslide dependencies via yum"
-            yum groupinstall -y "Development Tools"
-            yum install -y tar curl libpng-devel libjpeg-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel gdk-pixbuf2-devel sqlite-devel cairo-devel glib2-devel 
-            install_libopenslide_from_source "--prefix=/usr"
-            ;;
-          "Fedora release 21 "*|"Fedora release 22 "*)
-            # Fedora 21, 22
-            echo "Installing libopenslide via yum"
-            yum install -y openslide-devel
-            ;;
-          *)
-            # Unsupported RHEL-based OS
-            sorry "openslide" "$RELEASE"
-            ;;
-        esac
-      elif [ -f /etc/os-release ]; then
-        RELEASE=$(cat /etc/os-release | grep VERSION)
-        echo "Detected OpenSuse Linux '$RELEASE'"
-        case $RELEASE in
-          *"13.2"*)
-          echo "Installing libopenslide via zypper"
-          zypper --gpg-auto-import-keys install -y libopenslide-devel
-          ;;
-        esac
-      elif [ -f /etc/SuSE-brand ]; then
-        RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
-        echo "Detected OpenSuse Linux '$RELEASE'"
-        case $RELEASE in
-          *"13.1")
-          echo "Installing libopenslide dependencies via zypper"
-          zypper --gpg-auto-import-keys install -y --type pattern devel_basis
-          zypper --gpg-auto-import-keys install -y tar curl libpng16-devel libjpeg-turbo libjpeg8-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel libgdk_pixbuf-2_0-0 sqlite3-devel cairo-devel glib2-devel
-          install_libopenslide_from_source
-          ;;
-        esac
-      else
-        # Unsupported OS
-        sorry "openslide" "$(uname -a)"
-      fi
+    esac
+  elif [ -f /etc/SuSE-brand ]; then
+    RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
+    echo "Detected OpenSuse Linux '$RELEASE'"
+    case $RELEASE in
+      *"13.1")
+      echo "Installing libopenslide dependencies via zypper"
+      zypper --gpg-auto-import-keys install -y --type pattern devel_basis
+      zypper --gpg-auto-import-keys install -y tar curl libpng16-devel libjpeg-turbo libjpeg8-devel libxml2-devel zlib-devel openjpeg-devel libtiff-devel libgdk_pixbuf-2_0-0 sqlite3-devel cairo-devel glib2-devel
+      install_libopenslide_from_source
       ;;
-  esac
+    esac
+  else
+    # Unsupported OS
+    sorry "openslide" "$(uname -a)"
+  fi
 fi
 
 # OS-specific installations of libvips follows
 
-case $(uname -s) in
-  *[Dd]arwin*)
-    # Mac OS
-    echo "Detected Mac OS"
-    if type "brew" > /dev/null; then
-      echo "Installing libvips via homebrew"
+if [ -f /etc/debian_version ]; then
+  # Debian Linux
+  DISTRO=$(lsb_release -c -s)
+  echo "Detected Debian Linux '$DISTRO'"
+  case "$DISTRO" in
+    jessie|vivid)
+      # Debian 8, Ubuntu 15
       if [ $enable_openslide -eq 1 ]; then
-        brew install homebrew/science/vips --with-webp --with-graphicsmagick --with-openslide
+        echo "Recompiling vips with openslide support"
+        install_libvips_from_source
       else
-        brew install homebrew/science/vips --with-webp --with-graphicsmagick
+        echo "Installing libvips via apt-get"
+        apt-get install -y libvips-dev libgsf-1-dev
       fi
-    elif type "port" > /dev/null; then
-      echo "Installing libvips via MacPorts"
-      port install vips
-    else
-      sorry "vips" "Mac OS without homebrew or MacPorts"
-    fi
+      ;;
+    trusty|utopic|qiana|rebecca|rafaela)
+      # Ubuntu 14, Mint 17
+      echo "Installing libvips dependencies via apt-get"
+      apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
+      install_libvips_from_source
+      ;;
+    precise|wheezy|maya)
+      # Debian 7, Ubuntu 12.04, Mint 13
+      echo "Installing libvips dependencies via apt-get"
+      add-apt-repository -y ppa:lyrasis/precise-backports
+      apt-get update
+      apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff4-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
+      install_libvips_from_source
+      ;;
+    *)
+      # Unsupported Debian-based OS
+      sorry "vips" "Debian-based $DISTRO"
+      ;;
+  esac
+elif [ -f /etc/redhat-release ]; then
+  # Red Hat Linux
+  RELEASE=$(cat /etc/redhat-release)
+  echo "Detected Red Hat Linux '$RELEASE'"
+  case $RELEASE in
+    "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
+      # RHEL/CentOS 7
+      echo "Installing libvips dependencies via yum"
+      yum groupinstall -y "Development Tools"
+      yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
+      install_libvips_from_source "--prefix=/usr"
+      ;;
+    "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
+      # RHEL/CentOS 6
+      echo "Installing libvips dependencies via yum"
+      yum groupinstall -y "Development Tools"
+      yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel curl
+      yum install -y http://li.nux.ro/download/nux/dextop/el6/x86_64/nux-dextop-release-0-2.el6.nux.noarch.rpm
+      yum install -y --enablerepo=nux-dextop gobject-introspection-devel
+      yum install -y http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
+      yum install -y --enablerepo=remi libwebp-devel
+      install_libvips_from_source "--prefix=/usr"
+      ;;
+    "Fedora release 21 "*|"Fedora release 22 "*)
+      # Fedora 21, 22
+      if [ $enable_openslide -eq 1 ]; then
+        echo "Installing libvips dependencies via yum"
+        yum groupinstall -y "Development Tools"
+        yum install -y gcc-c++ gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
+        echo "Compiling vips with openslide support"
+        install_libvips_from_source "--prefix=/usr"
+      else
+        echo "Installing libvips via yum"
+        yum install -y vips-devel
+      fi
+      ;;
+    *)
+      # Unsupported RHEL-based OS
+      sorry "vips" "$RELEASE"
+      ;;
+  esac
+elif [ -f /etc/system-release ]; then
+  # Probably Amazon Linux
+  RELEASE=$(cat /etc/system-release)
+  case $RELEASE in
+    "Amazon Linux AMI release 2014.09"|"Amazon Linux AMI release 2015.03")
+      # Amazon Linux
+      echo "Detected '$RELEASE'"
+      echo "Installing libvips dependencies via yum"
+      yum groupinstall -y "Development Tools"
+      yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
+      install_libvips_from_source "--prefix=/usr"
+      ;;
+    *)
+      # Unsupported Amazon Linux version
+      sorry "vips" "$RELEASE"
+      ;;
+  esac
+elif [ -f /etc/os-release ]; then
+  RELEASE=$(cat /etc/os-release | grep VERSION)
+  echo "Detected OpenSuse Linux '$RELEASE'"
+  case $RELEASE in
+    *"13.2"*)
+    echo "Installing libvips dependencies via zypper"
+    zypper --gpg-auto-import-keys install -y --type pattern devel_basis
+    zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
+    install_libvips_from_source
     ;;
-  *)
-    if [ -f /etc/debian_version ]; then
-      # Debian Linux
-      DISTRO=$(lsb_release -c -s)
-      echo "Detected Debian Linux '$DISTRO'"
-      case "$DISTRO" in
-        jessie|vivid)
-          # Debian 8, Ubuntu 15
-          if [ $enable_openslide -eq 1 ]; then
-            echo "Recompiling vips with openslide support"
-            install_libvips_from_source
-          else
-            echo "Installing libvips via apt-get"
-            apt-get install -y libvips-dev libgsf-1-dev
-          fi
-          ;;
-        trusty|utopic|qiana|rebecca)
-          # Ubuntu 14, Mint 17
-          echo "Installing libvips dependencies via apt-get"
-          apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
-          install_libvips_from_source
-          ;;
-        precise|wheezy|maya)
-          # Debian 7, Ubuntu 12.04, Mint 13
-          echo "Installing libvips dependencies via apt-get"
-          add-apt-repository -y ppa:lyrasis/precise-backports
-          apt-get update
-          apt-get install -y automake build-essential gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-dev libpng12-dev libwebp-dev libtiff4-dev libexif-dev libgsf-1-dev liblcms2-dev libxml2-dev swig libmagickcore-dev curl
-          install_libvips_from_source
-          ;;
-        *)
-          # Unsupported Debian-based OS
-          sorry "vips" "Debian-based $DISTRO"
-          ;;
-      esac
-    elif [ -f /etc/redhat-release ]; then
-      # Red Hat Linux
-      RELEASE=$(cat /etc/redhat-release)
-      echo "Detected Red Hat Linux '$RELEASE'"
-      case $RELEASE in
-        "Red Hat Enterprise Linux release 7."*|"CentOS Linux release 7."*|"Scientific Linux release 7."*)
-          # RHEL/CentOS 7
-          echo "Installing libvips dependencies via yum"
-          yum groupinstall -y "Development Tools"
-          yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
-          install_libvips_from_source "--prefix=/usr"
-          ;;
-        "Red Hat Enterprise Linux release 6."*|"CentOS release 6."*|"Scientific Linux release 6."*)
-          # RHEL/CentOS 6
-          echo "Installing libvips dependencies via yum"
-          yum groupinstall -y "Development Tools"
-          yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel curl
-          yum install -y http://li.nux.ro/download/nux/dextop/el6/x86_64/nux-dextop-release-0-2.el6.nux.noarch.rpm
-          yum install -y --enablerepo=nux-dextop gobject-introspection-devel
-          yum install -y http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
-          yum install -y --enablerepo=remi libwebp-devel
-          install_libvips_from_source "--prefix=/usr"
-          ;;
-        "Fedora release 21 "*|"Fedora release 22 "*)
-          # Fedora 21, 22
-          if [ $enable_openslide -eq 1 ]; then
-            echo "Installing libvips dependencies via yum"
-            yum groupinstall -y "Development Tools"
-            yum install -y gcc-c++ gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
-            echo "Compiling vips with openslide support"
-            install_libvips_from_source "--prefix=/usr"
-          else
-            echo "Installing libvips via yum"
-            yum install -y vips-devel
-          fi
-          ;;
-        *)
-          # Unsupported RHEL-based OS
-          sorry "vips" "$RELEASE"
-          ;;
-      esac
-    elif [ -f /etc/system-release ]; then
-      # Probably Amazon Linux
-      RELEASE=$(cat /etc/system-release)
-      case $RELEASE in
-        "Amazon Linux AMI release 2014.09"|"Amazon Linux AMI release 2015.03")
-          # Amazon Linux
-          echo "Detected '$RELEASE'"
-          echo "Installing libvips dependencies via yum"
-          yum groupinstall -y "Development Tools"
-          yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel libgsf-devel lcms-devel ImageMagick-devel gobject-introspection-devel libwebp-devel curl
-          install_libvips_from_source "--prefix=/usr"
-          ;;
-        *)
-          # Unsupported Amazon Linux version
-          sorry "vips" "$RELEASE"
-          ;;
-      esac
-    elif [ -f /etc/os-release ]; then
-      RELEASE=$(cat /etc/os-release | grep VERSION)
-      echo "Detected OpenSuse Linux '$RELEASE'"
-      case $RELEASE in
-        *"13.2"*)
-        echo "Installing libvips dependencies via zypper"
-        zypper --gpg-auto-import-keys install -y --type pattern devel_basis
-        zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
-        install_libvips_from_source
-        ;;
-      esac
-    elif [ -f /etc/SuSE-brand ]; then
-      RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
-      echo "Detected OpenSuse Linux '$RELEASE'"
-      case $RELEASE in
-        *"13.1")
-        echo "Installing libvips dependencies via zypper"
-        zypper --gpg-auto-import-keys install -y --type pattern devel_basis
-        zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
-        install_libvips_from_source
-        ;;
-      esac
-    else
-      # Unsupported OS
-      sorry "vips" "$(uname -a)"
-    fi
+  esac
+elif [ -f /etc/SuSE-brand ]; then
+  RELEASE=$(cat /etc/SuSE-brand | grep VERSION)
+  echo "Detected OpenSuse Linux '$RELEASE'"
+  case $RELEASE in
+    *"13.1")
+    echo "Installing libvips dependencies via zypper"
+    zypper --gpg-auto-import-keys install -y --type pattern devel_basis
+    zypper --gpg-auto-import-keys install -y tar curl gtk-doc libxml2-devel libjpeg-turbo libjpeg8-devel libpng16-devel libtiff-devel libexif-devel liblcms2-devel ImageMagick-devel gobject-introspection-devel libwebp-devel
+    install_libvips_from_source
     ;;
-esac
+  esac
+else
+  # Unsupported OS
+  sorry "vips" "$(uname -a)"
+fi

src/common.cc

@@ -7,20 +7,26 @@
 
 // Verify platform and compiler compatibility
 
+#if (VIPS_MAJOR_VERSION < 7 || (VIPS_MAJOR_VERSION == 7 && VIPS_MINOR_VERSION < 40))
+#error libvips version 7.40.0+ required - see http://sharp.dimens.io/page/install
+#endif
+
 #ifdef _WIN64
-#error Windows 64-bit is currently unsupported - see https://github.com/lovell/sharp#windows
+#error Windows 64-bit is currently unsupported - see http://sharp.dimens.io/page/install#windows
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
-#error GCC version 4.6+ is required for C++11 features - see https://github.com/lovell/sharp#prerequisites
+#error GCC version 4.6+ is required for C++11 features - see http://sharp.dimens.io/page/install#prerequisites
 #endif
 
 #if (defined(__clang__) && defined(__has_feature))
 #if (!__has_feature(cxx_range_for))
-#error clang version 3.0+ is required for C++11 features - see https://github.com/lovell/sharp#prerequisites
+#error clang version 3.0+ is required for C++11 features - see http://sharp.dimens.io/page/install#prerequisites
 #endif
 #endif
 
+#define EXIF_IFD0_ORIENTATION "exif-ifd0-Orientation"
+
 namespace sharp {
 
   // How many tasks are in the queue?
@@ -137,14 +143,30 @@ namespace sharp {
     int orientation = 0;
     const char *exif;
     if (
-      vips_image_get_typeof(image, "exif-ifd0-Orientation") != 0 &&
-      !vips_image_get_string(image, "exif-ifd0-Orientation", &exif)
+      vips_image_get_typeof(image, EXIF_IFD0_ORIENTATION) != 0 &&
+      !vips_image_get_string(image, EXIF_IFD0_ORIENTATION, &exif)
     ) {
       orientation = atoi(&exif[0]);
     }
     return orientation;
   }
 
+  /*
+    Set EXIF Orientation of image.
+  */
+  void SetExifOrientation(VipsImage *image, int const orientation) {
+    char exif[3];
+    g_snprintf(exif, sizeof(exif), "%d", orientation);
+    vips_image_set_string(image, EXIF_IFD0_ORIENTATION, exif);
+  }
+
+  /*
+    Remove EXIF Orientation from image.
+  */
+  void RemoveExifOrientation(VipsImage *image) {
+    vips_image_remove(image, EXIF_IFD0_ORIENTATION);
+  }
+
   /*
     Returns the window size for the named interpolator. For example,
     a window size of 3 means a 3x3 pixel grid is used for the calculation.

src/common.h

@@ -1,6 +1,8 @@
 #ifndef SRC_COMMON_H_
 #define SRC_COMMON_H_
 
+#include <string>
+
 namespace sharp {
 
   enum class ImageType {
@@ -62,6 +64,16 @@ namespace sharp {
   */
   int ExifOrientation(VipsImage const *image);
 
+  /*
+    Set EXIF Orientation of image.
+  */
+  void SetExifOrientation(VipsImage *image, int const orientation);
+
+  /*
+    Remove EXIF Orientation from image.
+  */
+  void RemoveExifOrientation(VipsImage *image);
+
   /*
     Returns the window size for the named interpolator. For example,
     a window size of 3 means a 3x3 pixel grid is used for the calculation.

src/metadata.cc

@@ -27,7 +27,7 @@ using sharp::counterQueue;
 struct MetadataBaton {
   // Input
   std::string fileIn;
-  void* bufferIn;
+  char *bufferIn;
   size_t bufferInLength;
   // Output
   std::string format;
@@ -38,13 +38,29 @@ struct MetadataBaton {
   bool hasProfile;
   bool hasAlpha;
   int orientation;
+  char *exif;
+  size_t exifLength;
+  char *icc;
+  size_t iccLength;
   std::string err;
 
   MetadataBaton():
     bufferInLength(0),
-    orientation(0) {}
+    orientation(0),
+    exifLength(0),
+    iccLength(0) {}
 };
 
+/*
+  Delete input char[] buffer and notify V8 of memory deallocation
+  Used as the callback function for the "postclose" signal
+*/
+static void DeleteBuffer(VipsObject *object, char *buffer) {
+  if (buffer != NULL) {
+    delete[] buffer;
+  }
+}
+
 class MetadataWorker : public NanAsyncWorker {
 
  public:
@@ -57,17 +73,22 @@ class MetadataWorker : public NanAsyncWorker {
 
     ImageType imageType = ImageType::UNKNOWN;
     VipsImage *image = NULL;
-    if (baton->bufferInLength > 1) {
+    if (baton->bufferInLength > 0) {
       // From buffer
       imageType = DetermineImageType(baton->bufferIn, baton->bufferInLength);
       if (imageType != ImageType::UNKNOWN) {
         image = InitImage(baton->bufferIn, baton->bufferInLength, VIPS_ACCESS_RANDOM);
-        if (image == NULL) {
+        if (image != NULL) {
+          // Listen for "postclose" signal to delete input buffer
+          g_signal_connect(image, "postclose", G_CALLBACK(DeleteBuffer), baton->bufferIn);
+        } else {
           (baton->err).append("Input buffer has corrupt header");
           imageType = ImageType::UNKNOWN;
+          DeleteBuffer(NULL, baton->bufferIn);
         }
       } else {
         (baton->err).append("Input buffer contains unsupported image format");
+        DeleteBuffer(NULL, baton->bufferIn);
       }
     } else {
       // From file
@@ -102,6 +123,26 @@ class MetadataWorker : public NanAsyncWorker {
       // Derived attributes
       baton->hasAlpha = HasAlpha(image);
       baton->orientation = ExifOrientation(image);
+      // EXIF
+      if (vips_image_get_typeof(image, VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
+        void* exif;
+        size_t exifLength;
+        if (!vips_image_get_blob(image, VIPS_META_EXIF_NAME, &exif, &exifLength)) {
+          baton->exifLength = exifLength;
+          baton->exif = new char[exifLength];
+          memcpy(baton->exif, exif, exifLength);
+        }
+      }
+      // ICC profile
+      if (vips_image_get_typeof(image, VIPS_META_ICC_NAME) == VIPS_TYPE_BLOB) {
+        void* icc;
+        size_t iccLength;
+        if (!vips_image_get_blob(image, VIPS_META_ICC_NAME, &icc, &iccLength)) {
+          baton->iccLength = iccLength;
+          baton->icc = new char[iccLength];
+          memcpy(baton->icc, icc, iccLength);
+        }
+      }
       // Drop image reference
       g_object_unref(image);
     }
@@ -130,6 +171,12 @@ class MetadataWorker : public NanAsyncWorker {
       if (baton->orientation > 0) {
         info->Set(NanNew<String>("orientation"), NanNew<Number>(baton->orientation));
       }
+      if (baton->exifLength > 0) {
+        info->Set(NanNew<String>("exif"), NanBufferUse(baton->exif, baton->exifLength));
+      }
+      if (baton->iccLength > 0) {
+        info->Set(NanNew<String>("icc"), NanBufferUse(baton->icc, baton->iccLength));
+      }
       argv[1] = info;
     }
     delete baton;
@@ -157,8 +204,10 @@ NAN_METHOD(metadata) {
   // Input Buffer object
   if (options->Get(NanNew<String>("bufferIn"))->IsObject()) {
     Local<Object> buffer = options->Get(NanNew<String>("bufferIn"))->ToObject();
+    // Take a copy of the input Buffer to avoid problems with V8 heap compaction
     baton->bufferInLength = node::Buffer::Length(buffer);
-    baton->bufferIn = node::Buffer::Data(buffer);
+    baton->bufferIn = new char[baton->bufferInLength];
+    memcpy(baton->bufferIn, node::Buffer::Data(buffer), baton->bufferInLength);
   }
 
   // Join queue for worker thread

src/operations.cc

@@ -0,0 +1,333 @@
+#include <vips/vips.h>
+
+#include "common.h"
+#include "operations.h"
+
+namespace sharp {
+
+  /*
+    Alpha composite src over dst
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after
+   */
+  int Composite(VipsObject *context, VipsImage *src, VipsImage *dst, VipsImage **out) {
+    using sharp::HasAlpha;
+
+    // Split src into non-alpha and alpha
+    VipsImage *srcWithoutAlpha;
+    if (vips_extract_band(src, &srcWithoutAlpha, 0, "n", src->Bands - 1, NULL))
+      return -1;
+    vips_object_local(context, srcWithoutAlpha);
+    VipsImage *srcAlpha;
+    if (vips_extract_band(src, &srcAlpha, src->Bands - 1, "n", 1, NULL))
+      return -1;
+    vips_object_local(context, srcAlpha);
+
+    // Split dst into non-alpha and alpha channels
+    VipsImage *dstWithoutAlpha;
+    VipsImage *dstAlpha;
+    if (HasAlpha(dst)) {
+      // Non-alpha: extract all-but-last channel
+      if (vips_extract_band(dst, &dstWithoutAlpha, 0, "n", dst->Bands - 1, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, dstWithoutAlpha);
+      // Alpha: Extract last channel
+      if (vips_extract_band(dst, &dstAlpha, dst->Bands - 1, "n", 1, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, dstAlpha);
+    } else {
+      // Non-alpha: Copy reference
+      dstWithoutAlpha = dst;
+      // Alpha: Use blank, opaque (0xFF) image
+      VipsImage *black;
+      if (vips_black(&black, dst->Xsize, dst->Ysize, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, black);
+      if (vips_invert(black, &dstAlpha, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, dstAlpha);
+    }
+
+    // Compute normalized input alpha channels:
+    VipsImage *srcAlphaNormalized;
+    if (vips_linear1(srcAlpha, &srcAlphaNormalized, 1.0 / 255.0, 0.0, NULL))
+      return -1;
+    vips_object_local(context, srcAlphaNormalized);
+
+    VipsImage *dstAlphaNormalized;
+    if (vips_linear1(dstAlpha, &dstAlphaNormalized, 1.0 / 255.0, 0.0, NULL))
+      return -1;
+    vips_object_local(context, dstAlphaNormalized);
+
+    //
+    // Compute normalized output alpha channel:
+    //
+    // References:
+    // - http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending
+    // - https://github.com/jcupitt/ruby-vips/issues/28#issuecomment-9014826
+    //
+    // out_a = src_a + dst_a * (1 - src_a)
+    //                         ^^^^^^^^^^^
+    //                            t0
+    //                 ^^^^^^^^^^^^^^^^^^^
+    //                         t1
+    VipsImage *t0;
+    if (vips_linear1(srcAlphaNormalized, &t0, -1.0, 1.0, NULL))
+      return -1;
+    vips_object_local(context, t0);
+
+    VipsImage *t1;
+    if (vips_multiply(dstAlphaNormalized, t0, &t1, NULL))
+      return -1;
+    vips_object_local(context, t1);
+
+    VipsImage *outAlphaNormalized;
+    if (vips_add(srcAlphaNormalized, t1, &outAlphaNormalized, NULL))
+      return -1;
+    vips_object_local(context, outAlphaNormalized);
+
+    //
+    // Compute output RGB channels:
+    //
+    // Wikipedia:
+    // out_rgb = (src_rgb * src_a + dst_rgb * dst_a * (1 - src_a)) / out_a
+    //                                                ^^^^^^^^^^^
+    //                                                    t0
+    //
+    // Omit division by `out_a` since `Compose` is supposed to output a
+    // premultiplied RGBA image as reversal of premultiplication is handled
+    // externally.
+    //
+    VipsImage *t2;
+    if (vips_multiply(dstWithoutAlpha, t0, &t2, NULL))
+      return -1;
+    vips_object_local(context, t2);
+
+    VipsImage *outRGBPremultiplied;
+    if (vips_add(srcWithoutAlpha, t2, &outRGBPremultiplied, NULL))
+      return -1;
+    vips_object_local(context, outRGBPremultiplied);
+
+    // Denormalize output alpha channel:
+    VipsImage *outAlpha;
+    if (vips_linear1(outAlphaNormalized, &outAlpha, 255.0, 0.0, NULL))
+      return -1;
+    vips_object_local(context, outAlpha);
+
+    // Combine RGB and alpha channel into output image:
+    return vips_bandjoin2(outRGBPremultiplied, outAlpha, out, NULL);
+  }
+
+  /*
+   * Premultiply alpha channel of `image`.
+   */
+  int Premultiply(VipsObject *context, VipsImage *image, VipsImage **out) {
+#if (VIPS_MAJOR_VERSION >= 9 || (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 1))
+    return vips_premultiply(image, out, NULL);
+#else
+    VipsImage *imageRGB;
+    if (vips_extract_band(image, &imageRGB, 0, "n", image->Bands - 1, NULL))
+      return -1;
+    vips_object_local(context, imageRGB);
+
+    VipsImage *imageAlpha;
+    if (vips_extract_band(image, &imageAlpha, image->Bands - 1, "n", 1, NULL))
+      return -1;
+    vips_object_local(context, imageAlpha);
+
+    VipsImage *imageAlphaNormalized;
+    if (vips_linear1(imageAlpha, &imageAlphaNormalized, 1.0 / 255.0, 0.0, NULL))
+      return -1;
+    vips_object_local(context, imageAlphaNormalized);
+
+    VipsImage *imageRGBPremultiplied;
+    if (vips_multiply(imageRGB, imageAlphaNormalized, &imageRGBPremultiplied, NULL))
+      return -1;
+    vips_object_local(context, imageRGBPremultiplied);
+
+    return vips_bandjoin2(imageRGBPremultiplied, imageAlpha, out, NULL);
+#endif
+  }
+
+  /*
+   * Unpremultiply alpha channel of `image`.
+   */
+  int Unpremultiply(VipsObject *context, VipsImage *image, VipsImage **out) {
+#if (VIPS_MAJOR_VERSION >= 9 || (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 1))
+    return vips_unpremultiply(image, out, NULL);
+#else
+    VipsImage *imageRGBPremultipliedTransformed;
+    if (vips_extract_band(image, &imageRGBPremultipliedTransformed, 0, "n", image->Bands - 1, NULL))
+      return -1;
+    vips_object_local(context, imageRGBPremultipliedTransformed);
+
+    VipsImage *imageAlphaTransformed;
+    if (vips_extract_band(image, &imageAlphaTransformed, image->Bands - 1, "n", 1, NULL))
+      return -1;
+    vips_object_local(context, imageAlphaTransformed);
+
+    VipsImage *imageAlphaNormalizedTransformed;
+    if (vips_linear1(imageAlphaTransformed, &imageAlphaNormalizedTransformed, 1.0 / 255.0, 0.0, NULL))
+      return -1;
+    vips_object_local(context, imageAlphaNormalizedTransformed);
+
+    VipsImage *imageRGBUnpremultipliedTransformed;
+    if (vips_divide(imageRGBPremultipliedTransformed, imageAlphaNormalizedTransformed, &imageRGBUnpremultipliedTransformed, NULL))
+      return -1;
+    vips_object_local(context, imageRGBUnpremultipliedTransformed);
+
+    return vips_bandjoin2(imageRGBUnpremultipliedTransformed, imageAlphaTransformed, out, NULL);
+#endif
+  }
+
+  /*
+   * Stretch luminance to cover full dynamic range.
+   */
+  int Normalize(VipsObject *context, VipsImage *image, VipsImage **out) {
+#ifndef _WIN32
+    // Get original colourspace
+    VipsInterpretation typeBeforeNormalize = image->Type;
+    if (typeBeforeNormalize == VIPS_INTERPRETATION_RGB) {
+      typeBeforeNormalize = VIPS_INTERPRETATION_sRGB;
+    }
+    // Convert to LAB colourspace
+    VipsImage *lab;
+    if (vips_colourspace(image, &lab, VIPS_INTERPRETATION_LAB, NULL)) {
+      return -1;
+    }
+    vips_object_local(context, lab);
+    // Extract luminance
+    VipsImage *luminance;
+    if (vips_extract_band(lab, &luminance, 0, "n", 1, NULL)) {
+      return -1;
+    }
+    vips_object_local(context, luminance);
+    // Extract chroma
+    VipsImage *chroma;
+    if (vips_extract_band(lab, &chroma, 1, "n", 2, NULL)) {
+      return -1;
+    }
+    vips_object_local(context, chroma);
+    // Find luminance range
+    VipsImage *stats;
+    if (vips_stats(luminance, &stats, NULL)) {
+      return -1;
+    }
+    vips_object_local(context, stats);
+    double min = *VIPS_MATRIX(stats, 0, 0);
+    double max = *VIPS_MATRIX(stats, 1, 0);
+    if (min != max) {
+      double f = 100.0 / (max - min);
+      double a = -(min * f);
+      // Scale luminance
+      VipsImage *luminance100;
+      if (vips_linear1(luminance, &luminance100, f, a, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, luminance100);
+      // Join scaled luminance to chroma
+      VipsImage *normalizedLab;
+      if (vips_bandjoin2(luminance100, chroma, &normalizedLab, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, normalizedLab);
+      // Convert to original colourspace
+      VipsImage *normalized;
+      if (vips_colourspace(normalizedLab, &normalized, typeBeforeNormalize, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, normalized);
+      // Attach original alpha channel, if any
+      if (HasAlpha(image)) {
+        // Extract original alpha channel
+        VipsImage *alpha;
+        if (vips_extract_band(image, &alpha, image->Bands - 1, "n", 1, NULL)) {
+          return -1;
+        }
+        vips_object_local(context, alpha);
+        // Join alpha channel to normalised image
+        VipsImage *normalizedAlpha;
+        if (vips_bandjoin2(normalized, alpha, &normalizedAlpha, NULL)) {
+          return -1;
+        }
+        vips_object_local(context, normalizedAlpha);
+        *out = normalizedAlpha;
+      } else {
+        *out = normalized;
+      }
+    } else {
+      // Cannot normalise zero-range image
+      *out = image;
+    }
+#else
+    // The normalize operation is currently unsupported on Windows
+    // See https://github.com/lovell/sharp/issues/152
+    *out = image;
+#endif
+    return 0;
+  }
+
+  /*
+   * Gaussian blur (use sigma <0 for fast blur)
+   */
+  int Blur(VipsObject *context, VipsImage *image, VipsImage **out, double sigma) {
+    VipsImage *blurred;
+    if (sigma < 0.0) {
+      // Fast, mild blur - averages neighbouring pixels
+      VipsImage *blur = vips_image_new_matrixv(3, 3,
+        1.0, 1.0, 1.0,
+        1.0, 1.0, 1.0,
+        1.0, 1.0, 1.0);
+      vips_image_set_double(blur, "scale", 9);
+      vips_object_local(context, blur);
+      if (vips_conv(image, &blurred, blur, NULL)) {
+        return -1;
+      }
+    } else {
+      // Slower, accurate Gaussian blur
+      // Create Gaussian function for standard deviation
+      VipsImage *gaussian;
+      if (vips_gaussmat(&gaussian, sigma, 0.2, "separable", TRUE, "integer", TRUE, NULL)) {
+        return -1;
+      }
+      vips_object_local(context, gaussian);
+      // Apply Gaussian function
+      if (vips_convsep(image, &blurred, gaussian, "precision", VIPS_PRECISION_INTEGER, NULL)) {
+        return -1;
+      }
+    }
+    vips_object_local(context, blurred);
+    *out = blurred;
+    return 0;
+  }
+
+  /*
+   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   */
+  int Sharpen(VipsObject *context, VipsImage *image, VipsImage **out, int radius, double flat, double jagged) {
+    VipsImage *sharpened;
+    if (radius == -1) {
+      // Fast, mild sharpen
+      VipsImage *sharpen = vips_image_new_matrixv(3, 3,
+        -1.0, -1.0, -1.0,
+        -1.0, 32.0, -1.0,
+        -1.0, -1.0, -1.0);
+      vips_image_set_double(sharpen, "scale", 24);
+      vips_object_local(context, sharpen);
+      if (vips_conv(image, &sharpened, sharpen, NULL)) {
+        return -1;
+      }
+    } else {
+      // Slow, accurate sharpen in LAB colour space, with control over flat vs jagged areas
+      if (vips_sharpen(image, &sharpened, "radius", radius, "m1", flat, "m2", jagged, NULL)) {
+        return -1;
+      }
+    }
+    vips_object_local(context, sharpened);
+    *out = sharpened;
+    return 0;
+  }
+}  // namespace sharp

src/operations.h

@@ -0,0 +1,39 @@
+#ifndef SRC_OPERATIONS_H_
+#define SRC_OPERATIONS_H_
+
+namespace sharp {
+
+  /*
+    Composite images `src` and `dst` with premultiplied alpha channel and output
+    image with premultiplied alpha.
+   */
+  int Composite(VipsObject *context, VipsImage *src, VipsImage *dst, VipsImage **out);
+
+  /*
+   * Premultiply alpha channel of `image`.
+   */
+  int Premultiply(VipsObject *context, VipsImage *image, VipsImage **out);
+
+  /*
+   * Unpremultiply alpha channel of `image`.
+   */
+  int Unpremultiply(VipsObject *context, VipsImage *image, VipsImage **out);
+
+  /*
+   * Stretch luminance to cover full dynamic range.
+   */
+  int Normalize(VipsObject *context, VipsImage *image, VipsImage **out);
+
+  /*
+   * Gaussian blur. Use sigma of -1 for fast blur.
+   */
+  int Blur(VipsObject *context, VipsImage *image, VipsImage **out, double sigma);
+
+  /*
+   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   */
+  int Sharpen(VipsObject *context, VipsImage *image, VipsImage **out, int radius, double flat, double jagged);
+
+}  // namespace sharp
+
+#endif  // SRC_OPERATIONS_H_

src/pipeline.cc

@@ -8,7 +8,8 @@
 #include "nan.h"
 
 #include "common.h"
-#include "resize.h"
+#include "operations.h"
+#include "pipeline.h"
 
 using v8::Handle;
 using v8::Local;
@@ -21,6 +22,13 @@ using v8::Array;
 using v8::Function;
 using v8::Exception;
 
+using sharp::Composite;
+using sharp::Premultiply;
+using sharp::Unpremultiply;
+using sharp::Normalize;
+using sharp::Blur;
+using sharp::Sharpen;
+
 using sharp::ImageType;
 using sharp::DetermineImageType;
 using sharp::InitImage;
@@ -28,6 +36,8 @@ using sharp::InterpolatorWindowSize;
 using sharp::HasProfile;
 using sharp::HasAlpha;
 using sharp::ExifOrientation;
+using sharp::SetExifOrientation;
+using sharp::RemoveExifOrientation;
 using sharp::IsJpeg;
 using sharp::IsPng;
 using sharp::IsWebp;
@@ -52,7 +62,7 @@ enum class Angle {
   DLAST
 };
 
-struct ResizeBaton {
+struct PipelineBaton {
   std::string fileIn;
   char *bufferIn;
   size_t bufferInLength;
@@ -81,6 +91,7 @@ struct ResizeBaton {
   int sharpenRadius;
   double sharpenFlat;
   double sharpenJagged;
+  std::string overlayPath;
   double gamma;
   bool greyscale;
   bool normalize;
@@ -100,10 +111,11 @@ struct ResizeBaton {
   bool optimiseScans;
   std::string err;
   bool withMetadata;
+  int withMetadataOrientation;
   int tileSize;
   int tileOverlap;
 
-  ResizeBaton():
+  PipelineBaton():
     bufferInLength(0),
     limitInputPixels(0),
     outputFormat(""),
@@ -133,6 +145,7 @@ struct ResizeBaton {
     overshootDeringing(false),
     optimiseScans(false),
     withMetadata(false),
+    withMetadataOrientation(-1),
     tileSize(256),
     tileOverlap(0) {
       background[0] = 0.0;
@@ -152,12 +165,12 @@ static void DeleteBuffer(VipsObject *object, char *buffer) {
   }
 }
 
-class ResizeWorker : public NanAsyncWorker {
+class PipelineWorker : public NanAsyncWorker {
 
  public:
-  ResizeWorker(NanCallback *callback, ResizeBaton *baton, NanCallback *queueListener) :
+  PipelineWorker(NanCallback *callback, PipelineBaton *baton, NanCallback *queueListener) :
     NanAsyncWorker(callback), baton(baton), queueListener(queueListener) {}
-  ~ResizeWorker() {}
+  ~PipelineWorker() {}
 
   /*
     libuv worker
@@ -178,7 +191,7 @@ class ResizeWorker : public NanAsyncWorker {
     // Input
     ImageType inputImageType = ImageType::UNKNOWN;
     VipsImage *image = NULL;
-    if (baton->bufferInLength > 1) {
+    if (baton->bufferInLength > 0) {
       // From buffer
       inputImageType = DetermineImageType(baton->bufferIn, baton->bufferInLength);
       if (inputImageType != ImageType::UNKNOWN) {
@@ -237,6 +250,7 @@ class ResizeWorker : public NanAsyncWorker {
       }
       vips_object_local(hook, rotated);
       image = rotated;
+      RemoveExifOrientation(image);
     }
 
     // Pre extraction
@@ -311,7 +325,7 @@ class ResizeWorker : public NanAsyncWorker {
       } else {
         // Auto height
         yfactor = xfactor;
-        baton->height = static_cast<int>(floor(static_cast<double>(inputHeight) / yfactor));
+        baton->height = static_cast<int>(round(static_cast<double>(inputHeight) / yfactor));
       }
     } else if (baton->height > 0) {
       // Fixed height
@@ -321,7 +335,7 @@ class ResizeWorker : public NanAsyncWorker {
       } else {
         // Auto width
         xfactor = yfactor;
-        baton->width = static_cast<int>(floor(static_cast<double>(inputWidth) / xfactor));
+        baton->width = static_cast<int>(round(static_cast<double>(inputWidth) / xfactor));
       }
     } else {
       // Identity transform
@@ -431,7 +445,7 @@ class ResizeWorker : public NanAsyncWorker {
     }
 
     // Gamma encoding (darken)
-    if (baton->gamma >= 1 && baton->gamma <= 3) {
+    if (baton->gamma >= 1 && baton->gamma <= 3 && !HasAlpha(image)) {
       VipsImage *gammaEncoded;
       if (vips_gamma(image, &gammaEncoded, "exponent", 1.0 / baton->gamma, NULL)) {
         return Error();
@@ -478,8 +492,27 @@ class ResizeWorker : public NanAsyncWorker {
       }
     }
 
+    bool shouldAffineTransform = xresidual != 0.0 || yresidual != 0.0;
+    bool shouldBlur = baton->blurSigma != 0.0;
+    bool shouldSharpen = baton->sharpenRadius != 0;
+    bool hasOverlay = !baton->overlayPath.empty();
+    bool shouldPremultiplyAlpha = HasAlpha(image) && (shouldAffineTransform || shouldBlur || shouldSharpen || hasOverlay);
+
+    // Premultiply image alpha channel before all transformations to avoid
+    // dark fringing around bright pixels
+    // See: http://entropymine.com/imageworsener/resizealpha/
+    if (shouldPremultiplyAlpha) {
+      VipsImage *imagePremultiplied;
+      if (Premultiply(hook, image, &imagePremultiplied)) {
+        (baton->err).append("Failed to premultiply alpha channel.");
+        return Error();
+      }
+      vips_object_local(hook, imagePremultiplied);
+      image = imagePremultiplied;
+    }
+
     // Use vips_affine with the remaining float part
-    if (xresidual != 0.0 || yresidual != 0.0) {
+    if (shouldAffineTransform) {
       // Use average of x and y residuals to compute sigma for Gaussian blur
       double residual = (xresidual + yresidual) / 2.0;
       // Apply Gaussian blur before large affine reductions
@@ -534,6 +567,7 @@ class ResizeWorker : public NanAsyncWorker {
       }
       vips_object_local(hook, rotated);
       image = rotated;
+      RemoveExifOrientation(image);
     }
 
     // Flip (mirror about Y axis)
@@ -544,6 +578,7 @@ class ResizeWorker : public NanAsyncWorker {
       }
       vips_object_local(hook, flipped);
       image = flipped;
+      RemoveExifOrientation(image);
     }
 
     // Flop (mirror about X axis)
@@ -554,6 +589,7 @@ class ResizeWorker : public NanAsyncWorker {
       }
       vips_object_local(hook, flopped);
       image = flopped;
+      RemoveExifOrientation(image);
     }
 
     // Crop/embed
@@ -644,62 +680,97 @@ class ResizeWorker : public NanAsyncWorker {
     }
 
     // Blur
-    if (baton->blurSigma != 0.0) {
+    if (shouldBlur) {
       VipsImage *blurred;
-      if (baton->blurSigma < 0.0) {
-        // Fast, mild blur - averages neighbouring pixels
-        VipsImage *blur = vips_image_new_matrixv(3, 3,
-          1.0, 1.0, 1.0,
-          1.0, 1.0, 1.0,
-          1.0, 1.0, 1.0);
-        vips_image_set_double(blur, "scale", 9);
-        vips_object_local(hook, blur);
-        if (vips_conv(image, &blurred, blur, NULL)) {
-          return Error();
-        }
-      } else {
-        // Slower, accurate Gaussian blur
-        // Create Gaussian function for standard deviation
-        VipsImage *gaussian;
-        if (vips_gaussmat(&gaussian, baton->blurSigma, 0.2, "separable", TRUE, "integer", TRUE, NULL)) {
-          return Error();
-        }
-        vips_object_local(hook, gaussian);
-        // Apply Gaussian function
-        if (vips_convsep(image, &blurred, gaussian, "precision", VIPS_PRECISION_INTEGER, NULL)) {
-          return Error();
-        }
+      if (Blur(hook, image, &blurred, baton->blurSigma)) {
+        return Error();
       }
-      vips_object_local(hook, blurred);
       image = blurred;
     }
 
     // Sharpen
-    if (baton->sharpenRadius != 0) {
+    if (shouldSharpen) {
       VipsImage *sharpened;
-      if (baton->sharpenRadius == -1) {
-        // Fast, mild sharpen
-        VipsImage *sharpen = vips_image_new_matrixv(3, 3,
-          -1.0, -1.0, -1.0,
-          -1.0, 32.0, -1.0,
-          -1.0, -1.0, -1.0);
-        vips_image_set_double(sharpen, "scale", 24);
-        vips_object_local(hook, sharpen);
-        if (vips_conv(image, &sharpened, sharpen, NULL)) {
-          return Error();
-        }
-      } else {
-        // Slow, accurate sharpen in LAB colour space, with control over flat vs jagged areas
-        if (vips_sharpen(image, &sharpened, "radius", baton->sharpenRadius, "m1", baton->sharpenFlat, "m2", baton->sharpenJagged, NULL)) {
-          return Error();
-        }
+      if (Sharpen(hook, image, &sharpened, baton->sharpenRadius, baton->sharpenFlat, baton->sharpenJagged)) {
+        return Error();
       }
-      vips_object_local(hook, sharpened);
       image = sharpened;
     }
 
+    // Composite with overlay, if present
+    if (hasOverlay) {
+      VipsImage *overlayImage = NULL;
+      ImageType overlayImageType = ImageType::UNKNOWN;
+      overlayImageType = DetermineImageType(baton->overlayPath.c_str());
+      if (overlayImageType != ImageType::UNKNOWN) {
+        overlayImage = InitImage(baton->overlayPath.c_str(), baton->accessMethod);
+        if (overlayImage == NULL) {
+          (baton->err).append("Overlay image has corrupt header");
+          return Error();
+        } else {
+          vips_object_local(hook, overlayImage);
+        }
+      } else {
+        (baton->err).append("Overlay image is of an unsupported image format");
+        return Error();
+      }
+      if (image->BandFmt != VIPS_FORMAT_UCHAR && image->BandFmt != VIPS_FORMAT_FLOAT) {
+        (baton->err).append("Expected image band format to be uchar or float: ");
+        (baton->err).append(vips_enum_nick(VIPS_TYPE_BAND_FORMAT, image->BandFmt));
+        return Error();
+      }
+      if (overlayImage->BandFmt != VIPS_FORMAT_UCHAR && overlayImage->BandFmt != VIPS_FORMAT_FLOAT) {
+        (baton->err).append("Expected overlay image band format to be uchar or float: ");
+        (baton->err).append(vips_enum_nick(VIPS_TYPE_BAND_FORMAT, overlayImage->BandFmt));
+        return Error();
+      }
+      if (!HasAlpha(overlayImage)) {
+        (baton->err).append("Overlay image must have an alpha channel");
+        return Error();
+      }
+      if (overlayImage->Xsize != image->Xsize && overlayImage->Ysize != image->Ysize) {
+        (baton->err).append("Overlay image must have same dimensions as resized image");
+        return Error();
+      }
+
+      // Ensure overlay is sRGB
+      VipsImage *overlayImageRGB;
+      if (vips_colourspace(overlayImage, &overlayImageRGB, VIPS_INTERPRETATION_sRGB, NULL)) {
+        return Error();
+      }
+      vips_object_local(hook, overlayImageRGB);
+
+      // Premultiply overlay
+      VipsImage *overlayImagePremultiplied;
+      if (Premultiply(hook, overlayImageRGB, &overlayImagePremultiplied)) {
+        (baton->err).append("Failed to premultiply alpha channel of overlay image.");
+        return Error();
+      }
+      vips_object_local(hook, overlayImagePremultiplied);
+
+      VipsImage *composited;
+      if (Composite(hook, overlayImagePremultiplied, image, &composited)) {
+        (baton->err).append("Failed to composite images");
+        return Error();
+      }
+      vips_object_local(hook, composited);
+      image = composited;
+    }
+
+    // Reverse premultiplication after all transformations:
+    if (shouldPremultiplyAlpha) {
+      VipsImage *imageUnpremultiplied;
+      if (Unpremultiply(hook, image, &imageUnpremultiplied)) {
+        (baton->err).append("Failed to unpremultiply alpha channel.");
+        return Error();
+      }
+
+      vips_object_local(hook, imageUnpremultiplied);
+      image = imageUnpremultiplied;
+    }
+
     // Gamma decoding (brighten)
-    if (baton->gamma >= 1 && baton->gamma <= 3) {
+    if (baton->gamma >= 1 && baton->gamma <= 3 && !HasAlpha(image)) {
       VipsImage *gammaDecoded;
       if (vips_gamma(image, &gammaDecoded, "exponent", baton->gamma, NULL)) {
         return Error();
@@ -708,98 +779,25 @@ class ResizeWorker : public NanAsyncWorker {
       image = gammaDecoded;
     }
 
-#ifndef _WIN32
-    // Apply normalization
+    // Apply normalization - stretch luminance to cover full dynamic range
     if (baton->normalize) {
-      VipsInterpretation typeBeforeNormalize = image->Type;
-      if (typeBeforeNormalize == VIPS_INTERPRETATION_RGB) {
-        typeBeforeNormalize = VIPS_INTERPRETATION_sRGB;
-      }
-
-      // normalize the luminance band in LAB space:
-      VipsImage *lab;
-      if (vips_colourspace(image, &lab, VIPS_INTERPRETATION_LAB, NULL)) {
-        return Error();
-      }
-      vips_object_local(hook, lab);
-
-      VipsImage *luminance;
-      if (vips_extract_band(lab, &luminance, 0, "n", 1, NULL)) {
-        return Error();
-      }
-      vips_object_local(hook, luminance);
-
-      VipsImage *chroma;
-      if (vips_extract_band(lab, &chroma, 1, "n", 2, NULL)) {
-        return Error();
-      }
-      vips_object_local(hook, chroma);
-
-      VipsImage *stats;
-      if (vips_stats(luminance, &stats, NULL)) {
-        return Error();
-      }
-      vips_object_local(hook, stats);
-      double min = *VIPS_MATRIX(stats, 0, 0);
-      double max = *VIPS_MATRIX(stats, 1, 0);
-
       VipsImage *normalized;
-      if (min == max) {
-        // Range of zero: create black image
-        if (vips_black(&normalized, image->Xsize, image->Ysize, "bands", 1, NULL )) {
-          return Error();
-        }
-        vips_object_local(hook, normalized);
-      } else {
-        double f = 100.0 / (max - min);
-        double a = -(min * f);
-
-        VipsImage *luminance100;
-        if (vips_linear1(luminance, &luminance100, f, a, NULL)) {
-          return Error();
-        }
-        vips_object_local(hook, luminance100);
-
-        VipsImage *normalizedLab;
-        if (vips_bandjoin2(luminance100, chroma, &normalizedLab, NULL)) {
-          return Error();
-        }
-        vips_object_local(hook, normalizedLab);
-        if (vips_colourspace(normalizedLab, &normalized, typeBeforeNormalize, NULL)) {
-          return Error();
-        }
-        vips_object_local(hook, normalized);
-      }
-
-      if (HasAlpha(image)) {
-        VipsImage *alpha;
-        if (vips_extract_band(image, &alpha, image->Bands - 1, "n", 1, NULL)) {
-          return Error();
-        }
-        vips_object_local(hook, alpha);
-
-        VipsImage *normalizedAlpha;
-        if (vips_bandjoin2(normalized, alpha, &normalizedAlpha, NULL)) {
-          return Error();
-        }
-        vips_object_local(hook, normalizedAlpha);
-        image = normalizedAlpha;
-      } else {
-        image = normalized;
+      if (Normalize(hook, image, &normalized)) {
+        return Error();
       }
+      image = normalized;
     }
-#endif
 
     // Convert image to sRGB, if not already
     if (image->Type != VIPS_INTERPRETATION_sRGB) {
-      // Switch intrepretation to sRGB
+      // Switch interpretation to sRGB
       VipsImage *rgb;
       if (vips_colourspace(image, &rgb, VIPS_INTERPRETATION_sRGB, NULL)) {
         return Error();
       }
       vips_object_local(hook, rgb);
       image = rgb;
-      // Tranform colours from embedded profile to sRGB profile
+      // Transform colours from embedded profile to sRGB profile
       if (baton->withMetadata && HasProfile(image)) {
         VipsImage *profiled;
         if (vips_icc_transform(image, &profiled, srgbProfile.c_str(), "embedded", TRUE, NULL)) {
@@ -810,6 +808,11 @@ class ResizeWorker : public NanAsyncWorker {
       }
     }
 
+    // Override EXIF Orientation tag
+    if (baton->withMetadata && baton->withMetadataOrientation != -1) {
+      SetExifOrientation(image, baton->withMetadataOrientation);
+    }
+
 #if !(VIPS_MAJOR_VERSION >= 8 || (VIPS_MAJOR_VERSION >= 7 && VIPS_MINOR_VERSION >= 40 && VIPS_MINOR_VERSION >= 5))
     // Generate image tile cache when interlace output is required - no longer required as of libvips 7.40.5+
     if (baton->progressive) {
@@ -1012,7 +1015,7 @@ class ResizeWorker : public NanAsyncWorker {
   }
 
  private:
-  ResizeBaton *baton;
+  PipelineBaton *baton;
   NanCallback *queueListener;
   VipsObject *hook;
 
@@ -1120,13 +1123,13 @@ class ResizeWorker : public NanAsyncWorker {
 };
 
 /*
-  resize(options, output, callback)
+  pipeline(options, output, callback)
 */
-NAN_METHOD(resize) {
+NAN_METHOD(pipeline) {
   NanScope();
 
   // V8 objects are converted to non-V8 types held in the baton struct
-  ResizeBaton *baton = new ResizeBaton;
+  PipelineBaton *baton = new PipelineBaton;
   Local<Object> options = args[0]->ToObject();
 
   // Input filename
@@ -1139,7 +1142,6 @@ NAN_METHOD(resize) {
     baton->bufferInLength = node::Buffer::Length(buffer);
     baton->bufferIn = new char[baton->bufferInLength];
     memcpy(baton->bufferIn, node::Buffer::Data(buffer), baton->bufferInLength);
-    options->Set(NanNew<String>("bufferIn"), NanNull());
   }
   // ICC profile to use when input CMYK image has no embedded profile
   baton->iccProfilePath = *String::Utf8Value(options->Get(NanNew<String>("iccProfilePath"))->ToString());
@@ -1175,6 +1177,8 @@ NAN_METHOD(resize) {
   for (int i = 0; i < 4; i++) {
     baton->background[i] = background->Get(i)->NumberValue();
   }
+  // Overlay options
+  baton->overlayPath = *String::Utf8Value(options->Get(NanNew<String>("overlayPath"))->ToString());
   // Resize options
   baton->withoutEnlargement = options->Get(NanNew<String>("withoutEnlargement"))->BooleanValue();
   baton->gravity = options->Get(NanNew<String>("gravity"))->Int32Value();
@@ -1202,6 +1206,7 @@ NAN_METHOD(resize) {
   baton->overshootDeringing = options->Get(NanNew<String>("overshootDeringing"))->BooleanValue();
   baton->optimiseScans = options->Get(NanNew<String>("optimiseScans"))->BooleanValue();
   baton->withMetadata = options->Get(NanNew<String>("withMetadata"))->BooleanValue();
+  baton->withMetadataOrientation = options->Get(NanNew<String>("withMetadataOrientation"))->Int32Value();
   // Output filename or __format for Buffer
   baton->output = *String::Utf8Value(options->Get(NanNew<String>("output"))->ToString());
   baton->tileSize = options->Get(NanNew<String>("tileSize"))->Int32Value();
@@ -1211,7 +1216,7 @@ NAN_METHOD(resize) {
 
   // Join queue for worker thread
   NanCallback *callback = new NanCallback(args[1].As<Function>());
-  NanAsyncQueueWorker(new ResizeWorker(callback, baton, queueListener));
+  NanAsyncQueueWorker(new PipelineWorker(callback, baton, queueListener));
 
   // Increment queued task counter
   g_atomic_int_inc(&counterQueue);

src/pipeline.h

@@ -0,0 +1,8 @@
+#ifndef SRC_PIPELINE_H_
+#define SRC_PIPELINE_H_
+
+#include "nan.h"
+
+NAN_METHOD(pipeline);
+
+#endif  // SRC_PIPELINE_H_

src/resize.h

@@ -1,8 +0,0 @@
-#ifndef SRC_RESIZE_H_
-#define SRC_RESIZE_H_
-
-#include "nan.h"
-
-NAN_METHOD(resize);
-
-#endif  // SRC_RESIZE_H_

src/sharp.cc

@@ -5,7 +5,7 @@
 
 #include "common.h"
 #include "metadata.h"
-#include "resize.h"
+#include "pipeline.h"
 #include "utilities.h"
 
 extern "C" void init(v8::Handle<v8::Object> target) {
@@ -18,12 +18,13 @@ extern "C" void init(v8::Handle<v8::Object> target) {
 
   // Methods available to JavaScript
   NODE_SET_METHOD(target, "metadata", metadata);
-  NODE_SET_METHOD(target, "resize", resize);
+  NODE_SET_METHOD(target, "pipeline", pipeline);
   NODE_SET_METHOD(target, "cache", cache);
   NODE_SET_METHOD(target, "concurrency", concurrency);
   NODE_SET_METHOD(target, "counters", counters);
   NODE_SET_METHOD(target, "libvipsVersion", libvipsVersion);
   NODE_SET_METHOD(target, "format", format);
+  NODE_SET_METHOD(target, "_maxColourDistance", _maxColourDistance);
 }
 
 NODE_MODULE(sharp, init)

src/utilities.cc

@@ -4,6 +4,7 @@
 #include "nan.h"
 
 #include "common.h"
+#include "operations.h"
 #include "utilities.h"
 
 using v8::Local;
@@ -12,9 +13,6 @@ using v8::Number;
 using v8::String;
 using v8::Boolean;
 
-using sharp::counterQueue;
-using sharp::counterProcess;
-
 /*
   Get and set cache memory and item limits
 */
@@ -63,6 +61,9 @@ NAN_METHOD(concurrency) {
   Get internal counters (queued tasks, processing tasks)
 */
 NAN_METHOD(counters) {
+  using sharp::counterProcess;
+  using sharp::counterQueue;
+
   NanScope();
   Local<Object> counters = NanNew<Object>();
   counters->Set(NanNew<String>("queue"), NanNew<Number>(counterQueue));
@@ -142,3 +143,109 @@ NAN_METHOD(format) {
 
   NanReturnValue(format);
 }
+
+/*
+  Synchronous, internal-only method used by some of the functional tests.
+  Calculates the maximum colour distance using the DE2000 algorithm
+  between two images of the same dimensions and number of channels.
+*/
+NAN_METHOD(_maxColourDistance) {
+  using sharp::Premultiply;
+  using sharp::DetermineImageType;
+  using sharp::ImageType;
+  using sharp::InitImage;
+  using sharp::HasAlpha;
+
+  NanScope();
+
+  // Create "hook" VipsObject to hang image references from
+  VipsObject *hook = reinterpret_cast<VipsObject*>(vips_image_new());
+
+  // Open input files
+  VipsImage *image1 = NULL;
+  ImageType imageType1 = DetermineImageType(*String::Utf8Value(args[0]));
+  if (imageType1 != ImageType::UNKNOWN) {
+    image1 = InitImage(*String::Utf8Value(args[0]), VIPS_ACCESS_SEQUENTIAL);
+    if (image1 == NULL) {
+      g_object_unref(hook);
+      return NanThrowError("Input file 1 has corrupt header");
+    } else {
+      vips_object_local(hook, image1);
+    }
+  } else {
+    g_object_unref(hook);
+    return NanThrowError("Input file 1 is of an unsupported image format");
+  }
+  VipsImage *image2 = NULL;
+  ImageType imageType2 = DetermineImageType(*String::Utf8Value(args[1]));
+  if (imageType2 != ImageType::UNKNOWN) {
+    image2 = InitImage(*String::Utf8Value(args[1]), VIPS_ACCESS_SEQUENTIAL);
+    if (image2 == NULL) {
+      g_object_unref(hook);
+      return NanThrowError("Input file 2 has corrupt header");
+    } else {
+      vips_object_local(hook, image2);
+    }
+  } else {
+    g_object_unref(hook);
+    return NanThrowError("Input file 2 is of an unsupported image format");
+  }
+
+  // Ensure same number of channels
+  if (image1->Bands != image2->Bands) {
+    g_object_unref(hook);
+    return NanThrowError("mismatchedBands");
+  }
+  // Ensure same dimensions
+  if (image1->Xsize != image2->Xsize || image1->Ysize != image2->Ysize) {
+    g_object_unref(hook);
+    return NanThrowError("mismatchedDimensions");
+  }
+
+  // Premultiply and remove alpha
+  if (HasAlpha(image1)) {
+    VipsImage *imagePremultiplied1;
+    if (Premultiply(hook, image1, &imagePremultiplied1)) {
+      g_object_unref(hook);
+      return NanThrowError(vips_error_buffer());
+    }
+    vips_object_local(hook, imagePremultiplied1);
+    VipsImage *imagePremultipliedNoAlpha1;
+    if (vips_extract_band(image1, &imagePremultipliedNoAlpha1, 1, "n", image1->Bands - 1, NULL)) {
+      g_object_unref(hook);
+      return NanThrowError(vips_error_buffer());
+    }
+    vips_object_local(hook, imagePremultipliedNoAlpha1);
+    image1 = imagePremultipliedNoAlpha1;
+  }
+  if (HasAlpha(image2)) {
+    VipsImage *imagePremultiplied2;
+    if (Premultiply(hook, image2, &imagePremultiplied2)) {
+      g_object_unref(hook);
+      return NanThrowError(vips_error_buffer());
+    }
+    vips_object_local(hook, imagePremultiplied2);
+    VipsImage *imagePremultipliedNoAlpha2;
+    if (vips_extract_band(image2, &imagePremultipliedNoAlpha2, 1, "n", image2->Bands - 1, NULL)) {
+      g_object_unref(hook);
+      return NanThrowError(vips_error_buffer());
+    }
+    vips_object_local(hook, imagePremultipliedNoAlpha2);
+    image2 = imagePremultipliedNoAlpha2;
+  }
+  // Calculate colour distance
+  VipsImage *difference;
+  if (vips_dE00(image1, image2, &difference, NULL)) {
+    g_object_unref(hook);
+    return NanThrowError(vips_error_buffer());
+  }
+  vips_object_local(hook, difference);
+  // Extract maximum distance
+  double maxColourDistance;
+  if (vips_max(difference, &maxColourDistance, NULL)) {
+    g_object_unref(hook);
+    return NanThrowError(vips_error_buffer());
+  }
+  g_object_unref(hook);
+  NanReturnValue(maxColourDistance);
+}

src/utilities.h

@@ -8,5 +8,6 @@ NAN_METHOD(concurrency);
 NAN_METHOD(counters);
 NAN_METHOD(libvipsVersion);
 NAN_METHOD(format);
+NAN_METHOD(_maxColourDistance);
 
 #endif  // SRC_UTILITIES_H_

test/bench/package.json

@@ -9,13 +9,14 @@
   },
   "devDependencies": {
     "imagemagick": "^0.1.3",
-    "imagemagick-native": "mash/node-imagemagick-native",
-    "gm": "^1.17.0",
-    "async": "^0.9.0",
-    "semver": "^4.3.0",
+    "imagemagick-native": "^1.8.0",
+    "gm": "^1.18.1",
+    "lwip": "^0.0.7",
+    "async": "^1.4.2",
+    "semver": "^5.0.1",
     "benchmark": "^1.0.0"
   },
-  "license": "Apache 2.0",
+  "license": "Apache-2.0",
   "engines": {
     "node": ">=0.10"
   }

test/bench/perf.js

@@ -10,6 +10,7 @@ var semver = require('semver');
 var imagemagick = require('imagemagick');
 var imagemagickNative = require('imagemagick-native');
 var gm = require('gm');
+var lwip = require('lwip');
 var sharp = require('../../index');
 
 var fixtures = require('../fixtures');
@@ -26,7 +27,48 @@ sharp.cache(0);
 async.series({
   jpeg: function(callback) {
     var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    (new Benchmark.Suite('jpeg')).add('imagemagick-file-file', {
+    (new Benchmark.Suite('jpeg')).add('lwip-file-file', {
+      defer: true,
+      fn: function(deferred) {
+        lwip.open(fixtures.inputJpg, function (err, image) {
+          if (err) {
+            throw err;
+          }
+          image.resize(width, height, 'linear', function (err, image) {
+            if (err) {
+              throw err;
+            }
+            image.writeFile(fixtures.outputJpg, {quality: 80}, function (err) {
+              if (err) {
+                throw err;
+              }
+              deferred.resolve();
+            });
+          });
+        });
+      }
+    }).add('lwip-buffer-buffer', {
+      defer: true,
+      fn: function(deferred) {
+        lwip.open(inputJpgBuffer, 'jpg', function (err, image) {
+          if (err) {
+            throw err;
+          }
+          image.resize(width, height, 'linear', function (err, image) {
+            if (err) {
+              throw err;
+            }
+            image.toBuffer('jpg', {quality: 80}, function (err, buffer) {
+              if (err) {
+                throw err;
+              }
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            });
+          });
+        });
+      }
+    }).add('imagemagick-file-file', {
       defer: true,
       fn: function(deferred) {
         imagemagick.resize({
@@ -404,7 +446,28 @@ async.series({
   png: function(callback) {
     var inputPngBuffer = fs.readFileSync(fixtures.inputPng);
     var pngSuite = new Benchmark.Suite('png');
-    pngSuite.add('imagemagick-file-file', {
+    pngSuite.add('lwip-buffer-buffer', {
+      defer: true,
+      fn: function(deferred) {
+        lwip.open(inputPngBuffer, 'png', function (err, image) {
+          if (err) {
+            throw err;
+          }
+          image.resize(width, height, 'linear', function (err, image) {
+            if (err) {
+              throw err;
+            }
+            image.toBuffer('png', function (err, buffer) {
+              if (err) {
+                throw err;
+              }
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            });
+          });
+        });
+      }
+    }).add('imagemagick-file-file', {
       defer: true,
       fn: function(deferred) {
         imagemagick.resize({
@@ -412,7 +475,6 @@ async.series({
           dstPath: fixtures.outputPng,
           width: width,
           height: height,
-          format: 'jpg',
           filter: magickFilter
         }, function(err) {
           if (err) {

test/fixtures/index.js

@@ -1,11 +1,43 @@
 'use strict';
 
 var path = require('path');
+var assert = require('assert');
+var sharp = require('../../index');
+var maxColourDistance = require('../../build/Release/sharp')._maxColourDistance;
 
+// Helpers
 var getPath = function(filename) {
   return path.join(__dirname, filename);
 };
 
+// Generates a 64-bit-as-binary-string image fingerprint
+// Based on the dHash gradient method - see http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html
+var fingerprint = function(image, callback) {
+  sharp(image)
+    .greyscale()
+    .normalise()
+    .resize(9, 8)
+    .ignoreAspectRatio()
+    .interpolateWith(sharp.interpolator.vertexSplitQuadraticBasisSpline)
+    .raw()
+    .toBuffer(function(err, data) {
+      if (err) {
+        callback(err);
+      } else {
+        var fingerprint = '';
+        for (var col = 0; col < 8; col++) {
+          var gradient = 0;
+          for (var row = 0; row < 8; row++) {
+            var left = data[row * 8 + col];
+            var right = data[row * 8 + col + 1];
+            fingerprint = fingerprint + (left < right ? '1' : '0');
+          }
+        }
+        callback(null, fingerprint);
+      }
+    });
+};
+
 module.exports = {
 
   inputJpg: getPath('2569067123_aca715a2ee_o.jpg'), // http://www.flickr.com/photos/grizdave/2569067123/
@@ -21,8 +53,16 @@ module.exports = {
   inputPngWithTransparency: getPath('blackbug.png'), // public domain
   inputPngWithGreyAlpha: getPath('grey-8bit-alpha.png'),
   inputPngWithOneColor: getPath('2x2_fdcce6.png'),
+  inputPngOverlayLayer0: getPath('alpha-layer-0-background.png'),
+  inputPngOverlayLayer1: getPath('alpha-layer-1-fill.png'),
+  inputPngOverlayLayer2: getPath('alpha-layer-2-ink.png'),
+  inputPngOverlayLayer1LowAlpha: getPath('alpha-layer-1-fill-low-alpha.png'),
+  inputPngOverlayLayer2LowAlpha: getPath('alpha-layer-2-ink-low-alpha.png'),
+  inputPngAlphaPremultiplicationSmall: getPath('alpha-premultiply-1024x768-paper.png'),
+  inputPngAlphaPremultiplicationLarge: getPath('alpha-premultiply-2048x1536-paper.png'),
 
   inputWebP: getPath('4.webp'), // http://www.gstatic.com/webp/gallery/4.webp
+  inputWebPWithTransparency: getPath('5_webp_a.webp'), // http://www.gstatic.com/webp/gallery3/5_webp_a.webp
   inputTiff: getPath('G31D.TIF'), // http://www.fileformat.info/format/tiff/sample/e6c9a6e5253348f4aef6d17b534360ab/index.htm
   inputGif: getPath('Crash_test.gif'), // http://upload.wikimedia.org/wikipedia/commons/e/e3/Crash_test.gif
   inputSvg: getPath('Wikimedia-logo.svg'), // http://commons.wikimedia.org/wiki/File:Wikimedia-logo.svg
@@ -35,6 +75,74 @@ module.exports = {
   outputWebP: getPath('output.webp'),
   outputZoinks: getPath('output.zoinks'), // an 'unknown' file extension
 
-  path: getPath // allows tests to write files to fixtures directory (for testing with human eyes)
+  // Path for tests requiring human inspection
+  path: getPath,
+
+  // Path for expected output images
+  expected: function(filename) {
+    return getPath(path.join('expected', filename));
+  },
+
+  // Verify similarity of expected vs actual images via fingerprint
+  // Specify distance threshold using `options={threshold: 42}`, default
+  // `threshold` is 5;
+  assertSimilar: function(expectedImage, actualImage, options, callback) {
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+
+    if (typeof options === 'undefined' && options === null) {
+      options = {};
+    }
+
+    if (options.threshold === null || typeof options.threshold === 'undefined') {
+      options.threshold = 5; // ~7% threshold
+    }
+
+    if (typeof options.threshold !== 'number') {
+      throw new TypeError('`options.threshold` must be a number');
+    }
+
+    if (typeof callback !== 'function') {
+      throw new TypeError('`callback` must be a function');
+    }
+
+    fingerprint(expectedImage, function(err, expectedFingerprint) {
+      if (err) return callback(err);
+      fingerprint(actualImage, function(err, actualFingerprint) {
+        if (err) return callback(err);
+        var distance = 0;
+        for (var i = 0; i < 64; i++) {
+          if (expectedFingerprint[i] !== actualFingerprint[i]) {
+            distance++;
+          }
+        }
+
+        if (distance > options.threshold) {
+          return callback(new Error('Expected maximum similarity distance: ' + options.threshold + '. Actual: ' + distance + '.'));
+        }
+
+        callback();
+      });
+    });
+  },
+
+  assertMaxColourDistance: function(actualImagePath, expectedImagePath, acceptedDistance) {
+    if (typeof actualImagePath !== 'string') {
+      throw new TypeError('`actualImagePath` must be a string; got ' + actualImagePath);
+    }
+    if (typeof expectedImagePath !== 'string') {
+      throw new TypeError('`expectedImagePath` must be a string; got ' + expectedImagePath);
+    }
+    if (typeof acceptedDistance !== 'number') {
+      // Default threshold
+      acceptedDistance = 1;
+    }
+    var distance = maxColourDistance(actualImagePath, expectedImagePath);
+    if (distance > acceptedDistance) {
+      throw new Error('Expected maximum absolute distance of ' + acceptedDistance + ', actual ' + distance);
+    }
+  }
 
 };

test/leak/sharp.supp

@@ -109,3 +109,35 @@
   ...
   fun:vips__init
 }
+
+# *magick warnings
+{
+  leak_magick_read
+  Memcheck:Leak
+  match-leak-kinds: definite,indirect,possible
+  ...
+  fun:ReadImage
+  ...
+  fun:vips__magick_read
+}
+{
+  leak_magick_read_header
+  Memcheck:Leak
+  match-leak-kinds: definite,indirect,possible
+  ...
+  fun:ReadImage
+  ...
+  fun:vips__magick_read_header
+}
+
+# glib g_file_read_link
+# https://github.com/GNOME/glib/commit/49a5d0f6f2aed99cd78f25655f137f4448e47d92
+{
+  leak_magick
+  Memcheck:Leak
+  match-leak-kinds: definite,indirect,possible
+  ...
+  fun:g_file_read_link
+  ...
+  fun:vips_gsf_path
+}

test/unit/alpha.js

@@ -1,9 +1,8 @@
 'use strict';
 
 var assert = require('assert');
-
-var sharp = require('../../index');
 var fixtures = require('../fixtures');
+var sharp = require('../../index');
 
 sharp.cache(0);
 
@@ -13,7 +12,12 @@ describe('Alpha transparency', function() {
     sharp(fixtures.inputPngWithTransparency)
       .flatten()
       .resize(400, 300)
-      .toFile(fixtures.path('output.flatten-black.jpg'), done);
+      .toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(400, info.width);
+        assert.strictEqual(300, info.height);
+        fixtures.assertSimilar(fixtures.expected('flatten-black.jpg'), data, done);
+      });
   });
 
   it('Flatten to RGB orange', function(done) {
@@ -21,7 +25,12 @@ describe('Alpha transparency', function() {
       .flatten()
       .background({r: 255, g: 102, b: 0})
       .resize(400, 300)
-      .toFile(fixtures.path('output.flatten-rgb-orange.jpg'), done);
+      .toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(400, info.width);
+        assert.strictEqual(300, info.height);
+        fixtures.assertSimilar(fixtures.expected('flatten-orange.jpg'), data, done);
+      });
   });
 
   it('Flatten to CSS/hex orange', function(done) {
@@ -29,7 +38,12 @@ describe('Alpha transparency', function() {
       .flatten()
       .background('#ff6600')
       .resize(400, 300)
-      .toFile(fixtures.path('output.flatten-hex-orange.jpg'), done);
+      .toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(400, info.width);
+        assert.strictEqual(300, info.height);
+        fixtures.assertSimilar(fixtures.expected('flatten-orange.jpg'), data, done);
+      });
   });
 
   it('Do not flatten', function(done) {
@@ -61,4 +75,38 @@ describe('Alpha transparency', function() {
       });
   });
 
+  it('Enlargement with non-nearest neighbor interpolation shouldn’t cause dark edges', function(done) {
+    var BASE_NAME = 'alpha-premultiply-enlargement-2048x1536-paper.png';
+    var actual = fixtures.path('output.' + BASE_NAME);
+    var expected = fixtures.expected(BASE_NAME);
+    sharp(fixtures.inputPngAlphaPremultiplicationSmall)
+      .resize(2048, 1536)
+      .interpolateWith('bicubic')
+      .toFile(actual, function(err) {
+        if (err) {
+          done(err);
+        } else {
+          fixtures.assertMaxColourDistance(actual, expected, 102);
+          done();
+        }
+      });
+  });
+
+  it('Reduction with non-nearest neighbor interpolation shouldn’t cause dark edges', function(done) {
+    var BASE_NAME = 'alpha-premultiply-reduction-1024x768-paper.png';
+    var actual = fixtures.path('output.' + BASE_NAME);
+    var expected = fixtures.expected(BASE_NAME);
+    sharp(fixtures.inputPngAlphaPremultiplicationLarge)
+      .resize(1024, 768)
+      .interpolateWith('bicubic')
+      .toFile(actual, function(err) {
+        if (err) {
+          done(err);
+        } else {
+          fixtures.assertMaxColourDistance(actual, expected, 102);
+          done();
+        }
+      });
+  });
+
 });

test/unit/clone.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var fs = require('fs');
+var assert = require('assert');
+
+var sharp = require('../../index');
+var fixtures = require('../fixtures');
+
+sharp.cache(0);
+
+describe('Clone', function() {
+  it('Read from Stream and write to multiple Streams', function(done) {
+    var finishEventsExpected = 2;
+    // Output stream 1
+    var output1 = fixtures.path('output.multi-stream.1.jpg');
+    var writable1 = fs.createWriteStream(output1);
+    writable1.on('finish', function() {
+      sharp(output1).toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(data.length, info.size);
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        fs.unlinkSync(output1);
+        finishEventsExpected--;
+        if (finishEventsExpected === 0) {
+          done();
+        }
+      });
+    });
+    // Output stream 2
+    var output2 = fixtures.path('output.multi-stream.2.jpg');
+    var writable2 = fs.createWriteStream(output2);
+    writable2.on('finish', function() {
+      sharp(output2).toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual(data.length, info.size);
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(100, info.width);
+        assert.strictEqual(122, info.height);
+        fs.unlinkSync(output2);
+        finishEventsExpected--;
+        if (finishEventsExpected === 0) {
+          done();
+        }
+      });
+    });
+    // Create parent instance
+    var rotator = sharp().rotate(90);
+    // Cloned instances with differing dimensions
+    rotator.clone().resize(320, 240).pipe(writable1);
+    rotator.clone().resize(100).pipe(writable2);
+    // Go
+    fs.createReadStream(fixtures.inputJpg).pipe(rotator);
+  });
+});

test/unit/crop.js

@@ -13,11 +13,11 @@ describe('Crop gravities', function() {
     sharp(fixtures.inputJpg)
       .resize(320, 80)
       .crop(sharp.gravity.north)
-      .toFile(fixtures.path('output.gravity-north.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(320, info.width);
         assert.strictEqual(80, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('gravity-north.jpg'), data, done);
       });
   });
 
@@ -25,11 +25,11 @@ describe('Crop gravities', function() {
     sharp(fixtures.inputJpg)
       .resize(80, 320)
       .crop(sharp.gravity.east)
-      .toFile(fixtures.path('output.gravity-east.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(80, info.width);
         assert.strictEqual(320, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('gravity-east.jpg'), data, done);
       });
   });
 
@@ -37,11 +37,11 @@ describe('Crop gravities', function() {
     sharp(fixtures.inputJpg)
       .resize(320, 80)
       .crop(sharp.gravity.south)
-      .toFile(fixtures.path('output.gravity-south.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(320, info.width);
         assert.strictEqual(80, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('gravity-south.jpg'), data, done);
       });
   });
 
@@ -49,11 +49,11 @@ describe('Crop gravities', function() {
     sharp(fixtures.inputJpg)
       .resize(80, 320)
       .crop(sharp.gravity.west)
-      .toFile(fixtures.path('output.gravity-west.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(80, info.width);
         assert.strictEqual(320, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('gravity-west.jpg'), data, done);
       });
   });
 
@@ -61,11 +61,11 @@ describe('Crop gravities', function() {
     sharp(fixtures.inputJpg)
       .resize(320, 80)
       .crop(sharp.gravity.center)
-      .toFile(fixtures.path('output.gravity-center.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(320, info.width);
         assert.strictEqual(80, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('gravity-center.jpg'), data, done);
       });
   });
 
@@ -73,23 +73,18 @@ describe('Crop gravities', function() {
     sharp(fixtures.inputJpg)
       .resize(80, 320)
       .crop(sharp.gravity.centre)
-      .toFile(fixtures.path('output.gravity-centre.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(80, info.width);
         assert.strictEqual(320, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('gravity-centre.jpg'), data, done);
       });
   });
 
-  it('Invalid', function(done) {
-    var isValid = true;
-    try {
+  it('Invalid', function() {
+    assert.throws(function() {
       sharp(fixtures.inputJpg).crop(5);
-    } catch (err) {
-      isValid = false;
-    }
-    assert.strictEqual(false, isValid);
-    done();
+    });
   });
 
 });

test/unit/embed.js

@@ -68,4 +68,18 @@ describe('Embed', function() {
       });
   });
 
+  it('Enlarge and embed', function(done) {
+    sharp(fixtures.inputPngWithOneColor)
+      .embed()
+      .resize(320, 240)
+      .toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual(true, data.length > 0);
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        fixtures.assertSimilar(fixtures.expected('embed-enlarge.png'), data, done);
+      });
+  });
+
 });

test/unit/extract.js

@@ -12,22 +12,22 @@ describe('Partial image extraction', function() {
   it('JPEG', function(done) {
     sharp(fixtures.inputJpg)
       .extract(2, 2, 20, 20)
-      .toFile(fixtures.path('output.extract.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(20, info.width);
         assert.strictEqual(20, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('extract.jpg'), data, done);
       });
   });
 
   it('PNG', function(done) {
     sharp(fixtures.inputPng)
       .extract(300, 200, 400, 200)
-      .toFile(fixtures.path('output.extract.png'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(400, info.width);
         assert.strictEqual(200, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('extract.png'), data, done);
       });
   });
 
@@ -35,11 +35,11 @@ describe('Partial image extraction', function() {
     it('WebP', function(done) {
       sharp(fixtures.inputWebP)
         .extract(50, 100, 125, 200)
-        .toFile(fixtures.path('output.extract.webp'), function(err, info) {
+        .toBuffer(function(err, data, info) {
           if (err) throw err;
           assert.strictEqual(125, info.width);
           assert.strictEqual(200, info.height);
-          done();
+          fixtures.assertSimilar(fixtures.expected('extract.webp'), data, done);
         });
     });
   }
@@ -47,11 +47,12 @@ describe('Partial image extraction', function() {
   it('TIFF', function(done) {
     sharp(fixtures.inputTiff)
       .extract(63, 34, 341, 529)
-      .toFile(fixtures.path('output.extract.tiff'), function(err, info) {
+      .jpeg()
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(341, info.width);
         assert.strictEqual(529, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('extract.tiff'), data, done);
       });
   });
 
@@ -59,11 +60,11 @@ describe('Partial image extraction', function() {
     sharp(fixtures.inputJpg)
       .extract(10, 10, 10, 500, 500)
       .resize(100, 100)
-      .toFile(fixtures.path('output.extract.resize.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(100, info.width);
         assert.strictEqual(100, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('extract-resize.jpg'), data, done);
       });
   });
 
@@ -72,11 +73,11 @@ describe('Partial image extraction', function() {
       .resize(500, 500)
       .crop(sharp.gravity.north)
       .extract(10, 10, 100, 100)
-      .toFile(fixtures.path('output.resize.crop.extract.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(100, info.width);
         assert.strictEqual(100, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('resize-crop-extract.jpg'), data, done);
       });
   });
 
@@ -86,11 +87,11 @@ describe('Partial image extraction', function() {
       .resize(500, 500)
       .crop(sharp.gravity.north)
       .extract(10, 10, 100, 100)
-      .toFile(fixtures.path('output.extract.resize.crop.extract.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(100, info.width);
         assert.strictEqual(100, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('extract-resize-crop-extract.jpg'), data, done);
       });
   });
 
@@ -98,11 +99,11 @@ describe('Partial image extraction', function() {
     sharp(fixtures.inputJpg)
       .extract(10, 10, 100, 100)
       .rotate(90)
-      .toFile(fixtures.path('output.extract.extract-then-rotate.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(100, info.width);
         assert.strictEqual(100, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('extract-rotate.jpg'), data, done);
       });
   });
 
@@ -110,69 +111,44 @@ describe('Partial image extraction', function() {
     sharp(fixtures.inputJpg)
       .rotate(90)
       .extract(10, 10, 100, 100)
-      .toFile(fixtures.path('output.extract.rotate-then-extract.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(100, info.width);
         assert.strictEqual(100, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('rotate-extract.jpg'), data, done);
       });
   });
 
   describe('Invalid parameters', function() {
 
-    it('Undefined', function(done) {
-      var isValid = true;
-      try {
+    it('Undefined', function() {
+      assert.throws(function() {
         sharp(fixtures.inputJpg).extract();
-      } catch (err) {
-        isValid = false;
-      }
-      assert.strictEqual(false, isValid);
-      done();
+      });
     });
 
-    it('String top', function(done) {
-      var isValid = true;
-      try {
+    it('String top', function() {
+      assert.throws(function() {
         sharp(fixtures.inputJpg).extract('spoons', 10, 10, 10);
-      } catch (err) {
-        isValid = false;
-      }
-      assert.strictEqual(false, isValid);
-      done();
+      });
     });
 
-    it('Non-integral left', function(done) {
-      var isValid = true;
-      try {
+    it('Non-integral left', function() {
+      assert.throws(function() {
         sharp(fixtures.inputJpg).extract(10, 10.2, 10, 10);
-      } catch (err) {
-        isValid = false;
-      }
-      assert.strictEqual(false, isValid);
-      done();
+      });
     });
 
-    it('Negative width - negative', function(done) {
-      var isValid = true;
-      try {
+    it('Negative width - negative', function() {
+      assert.throws(function() {
         sharp(fixtures.inputJpg).extract(10, 10, -10, 10);
-      } catch (err) {
-        isValid = false;
-      }
-      assert.strictEqual(false, isValid);
-      done();
+      });
     });
 
-    it('Null height', function(done) {
-      var isValid = true;
-      try {
+    it('Null height', function() {
+      assert.throws(function() {
         sharp(fixtures.inputJpg).extract(10, 10, 10, null);
-      } catch (err) {
-        isValid = false;
-      }
-      assert.strictEqual(false, isValid);
-      done();
+      });
     });
 
   });

test/unit/fixtures.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var assert = require('assert');
+var fixtures = require('../fixtures');
+
+describe('Test fixtures', function() {
+  describe('assertMaxColourDistance', function() {
+    it('should throw an Error when images have a different number of channels', function() {
+      assert.throws(function() {
+        fixtures.assertMaxColourDistance(fixtures.inputPngOverlayLayer1, fixtures.inputJpg);
+      });
+    });
+    it('should throw an Error when images have different dimensions', function() {
+      assert.throws(function() {
+        fixtures.assertMaxColourDistance(fixtures.inputJpg, fixtures.inputJpgWithExif);
+      });
+    });
+    it('should accept a zero threshold when comparing an image to itself', function() {
+      var image = fixtures.inputPngOverlayLayer0;
+      fixtures.assertMaxColourDistance(image, image, 0);
+    });
+    it('should accept a numeric threshold for two different images', function() {
+      fixtures.assertMaxColourDistance(fixtures.inputPngOverlayLayer0, fixtures.inputPngOverlayLayer1, 100);
+    });
+  });
+});

test/unit/gamma.js

@@ -12,32 +12,53 @@ describe('Gamma correction', function() {
   it('value of 0.0 (disabled)', function(done) {
     sharp(fixtures.inputJpgWithGammaHoliness)
       .resize(129, 111)
-      .toFile(fixtures.path('output.gamma-0.0.jpg'), done);
+      .toBuffer(function(err, data, info) {
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(129, info.width);
+        assert.strictEqual(111, info.height);
+        fixtures.assertSimilar(fixtures.expected('gamma-0.0.jpg'), data, done);
+      });
   });
 
   it('value of 2.2 (default)', function(done) {
     sharp(fixtures.inputJpgWithGammaHoliness)
       .resize(129, 111)
       .gamma()
-      .toFile(fixtures.path('output.gamma-2.2.jpg'), done);
+      .toBuffer(function(err, data, info) {
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(129, info.width);
+        assert.strictEqual(111, info.height);
+        fixtures.assertSimilar(fixtures.expected('gamma-2.2.jpg'), data, done);
+      });
   });
 
   it('value of 3.0', function(done) {
     sharp(fixtures.inputJpgWithGammaHoliness)
       .resize(129, 111)
       .gamma(3)
-      .toFile(fixtures.path('output.gamma-3.0.jpg'), done);
+      .toBuffer(function(err, data, info) {
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(129, info.width);
+        assert.strictEqual(111, info.height);
+        fixtures.assertSimilar(fixtures.expected('gamma-3.0.jpg'), data, done);
+      });
   });
 
-  it('invalid value', function(done) {
-    var isValid = true;
-    try {
+  it('alpha transparency', function(done) {
+    sharp(fixtures.inputPngOverlayLayer1)
+      .resize(320)
+      .gamma()
+      .toBuffer(function(err, data, info) {
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(320, info.width);
+        fixtures.assertSimilar(fixtures.expected('gamma-alpha.jpg'), data, done);
+      });
+  });
+
+  it('invalid value', function() {
+    assert.throws(function() {
       sharp(fixtures.inputJpgWithGammaHoliness).gamma(4);
-    } catch (err) {
-      isValid = false;
-    }
-    assert.strictEqual(false, isValid);
-    done();
+    });
   });
 
 });

test/unit/io.js

@@ -221,6 +221,29 @@ describe('Input/output', function() {
     });
   });
 
+  describe('Fail for unsupported input', function() {
+    it('Numeric', function() {
+      assert.throws(function() {
+        sharp(1);
+      });
+    });
+    it('Boolean', function() {
+      assert.throws(function() {
+        sharp(true);
+      });
+    });
+    it('Empty Object', function() {
+      assert.throws(function() {
+        sharp({});
+      });
+    });
+    it('Error Object', function() {
+      assert.throws(function() {
+        sharp(new Error());
+      });
+    });
+  });
+
   it('Promises/A+', function(done) {
     sharp(fixtures.inputJpg).resize(320, 240).toBuffer().then(function(data) {
       sharp(data).toBuffer(function(err, data, info) {
@@ -252,15 +275,22 @@ describe('Input/output', function() {
     });
   });
 
-  it('Invalid quality', function(done) {
-    var isValid = true;
-    try {
-      sharp(fixtures.inputJpg).quality(-1);
-    } catch (err) {
-      isValid = false;
-    }
-    assert.strictEqual(false, isValid);
-    done();
+  describe('Invalid quality', function() {
+    it('Negative integer', function() {
+      assert.throws(function() {
+        sharp(fixtures.inputJpg).quality(-1);
+      });
+    });
+    it('Non integral', function() {
+      assert.throws(function() {
+        sharp(fixtures.inputJpg).quality(88.2);
+      });
+    });
+    it('String', function() {
+      assert.throws(function() {
+        sharp(fixtures.inputJpg).quality('test');
+      });
+    });
   });
 
   it('Progressive JPEG image', function(done) {

test/unit/metadata.js

@@ -2,6 +2,8 @@
 
 var fs = require('fs');
 var assert = require('assert');
+var exifReader = require('exif-reader');
+var icc = require('icc');
 
 var sharp = require('../../index');
 var fixtures = require('../fixtures');
@@ -21,11 +23,13 @@ describe('Image metadata', function() {
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     });
   });
 
-  it('JPEG with EXIF', function(done) {
+  it('JPEG with EXIF/ICC', function(done) {
     sharp(fixtures.inputJpgWithExif).metadata(function(err, metadata) {
       if (err) throw err;
       assert.strictEqual('jpeg', metadata.format);
@@ -36,6 +40,19 @@ describe('Image metadata', function() {
       assert.strictEqual(true, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
       assert.strictEqual(8, metadata.orientation);
+      // EXIF
+      assert.strictEqual('object', typeof metadata.exif);
+      assert.strictEqual(true, metadata.exif instanceof Buffer);
+      var exif = exifReader(metadata.exif);
+      assert.strictEqual('object', typeof exif);
+      assert.strictEqual('object', typeof exif.image);
+      assert.strictEqual('number', typeof exif.image.XResolution);
+      // ICC
+      assert.strictEqual('object', typeof metadata.icc);
+      assert.strictEqual(true, metadata.icc instanceof Buffer);
+      var profile = icc.parse(metadata.icc);
+      assert.strictEqual('object', typeof profile);
+      assert.strictEqual('Generic RGB Profile', profile.description);
       done();
     });
   });
@@ -50,6 +67,9 @@ describe('Image metadata', function() {
       assert.strictEqual(1, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     });
   });
@@ -64,6 +84,9 @@ describe('Image metadata', function() {
       assert.strictEqual(1, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     });
   });
@@ -78,6 +101,9 @@ describe('Image metadata', function() {
       assert.strictEqual(4, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(true, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     });
   });
@@ -93,6 +119,9 @@ describe('Image metadata', function() {
         assert.strictEqual(3, metadata.channels);
         assert.strictEqual(false, metadata.hasProfile);
         assert.strictEqual(false, metadata.hasAlpha);
+        assert.strictEqual('undefined', typeof metadata.orientation);
+        assert.strictEqual('undefined', typeof metadata.exif);
+        assert.strictEqual('undefined', typeof metadata.icc);
         done();
       });
     });
@@ -107,6 +136,9 @@ describe('Image metadata', function() {
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     });
   });
@@ -122,6 +154,9 @@ describe('Image metadata', function() {
         assert.strictEqual('rgb', metadata.space);
         assert.strictEqual(false, metadata.hasProfile);
         assert.strictEqual(true, metadata.hasAlpha);
+        assert.strictEqual('undefined', typeof metadata.orientation);
+        assert.strictEqual('undefined', typeof metadata.exif);
+        assert.strictEqual('undefined', typeof metadata.icc);
         done();
       });
     });
@@ -136,6 +171,9 @@ describe('Image metadata', function() {
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     });
   });
@@ -160,6 +198,9 @@ describe('Image metadata', function() {
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     }).catch(function(err) {
       throw err;
@@ -178,6 +219,9 @@ describe('Image metadata', function() {
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       done();
     });
     readable.pipe(pipeline);
@@ -194,6 +238,9 @@ describe('Image metadata', function() {
       assert.strictEqual(3, metadata.channels);
       assert.strictEqual(false, metadata.hasProfile);
       assert.strictEqual(false, metadata.hasAlpha);
+      assert.strictEqual('undefined', typeof metadata.orientation);
+      assert.strictEqual('undefined', typeof metadata.exif);
+      assert.strictEqual('undefined', typeof metadata.icc);
       image.resize(Math.floor(metadata.width / 2)).toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
@@ -204,7 +251,7 @@ describe('Image metadata', function() {
     });
   });
 
-  it('Keep EXIF metadata after a resize', function(done) {
+  it('Keep EXIF metadata and add sRGB profile after a resize', function(done) {
     sharp(fixtures.inputJpgWithExif)
       .resize(320, 240)
       .withMetadata()
@@ -214,6 +261,19 @@ describe('Image metadata', function() {
           if (err) throw err;
           assert.strictEqual(true, metadata.hasProfile);
           assert.strictEqual(8, metadata.orientation);
+          assert.strictEqual('object', typeof metadata.exif);
+          assert.strictEqual(true, metadata.exif instanceof Buffer);
+          // EXIF
+          var exif = exifReader(metadata.exif);
+          assert.strictEqual('object', typeof exif);
+          assert.strictEqual('object', typeof exif.image);
+          assert.strictEqual('number', typeof exif.image.XResolution);
+          // ICC
+          assert.strictEqual('object', typeof metadata.icc);
+          assert.strictEqual(true, metadata.icc instanceof Buffer);
+          var profile = icc.parse(metadata.icc);
+          assert.strictEqual('object', typeof profile);
+          assert.strictEqual('sRGB IEC61966-2-1 black scaled', profile.description);
           done();
         });
       });
@@ -229,6 +289,8 @@ describe('Image metadata', function() {
           if (err) throw err;
           assert.strictEqual(false, metadata.hasProfile);
           assert.strictEqual('undefined', typeof metadata.orientation);
+          assert.strictEqual('undefined', typeof metadata.exif);
+          assert.strictEqual('undefined', typeof metadata.icc);
           done();
         });
       });
@@ -250,4 +312,21 @@ describe('Image metadata', function() {
       });
   });
 
+  describe('Invalid withMetadata parameters', function() {
+    it('String orientation', function() {
+      assert.throws(function() {
+        sharp().withMetadata({orientation: 'zoinks'});
+      });
+    });
+    it('Negative orientation', function() {
+      assert.throws(function() {
+        sharp().withMetadata({orientation: -1});
+      });
+    });
+    it('Too large orientation', function() {
+      assert.throws(function() {
+        sharp().withMetadata({orientation: 8});
+      });
+    });
+  });
 });

test/unit/normalize.js

@@ -29,7 +29,7 @@ describe('Normalization', function () {
           }
           assert.strictEqual(0, min);
           assert.strictEqual(255, max);
-          return done();
+          done();
         });
     });
 
@@ -48,7 +48,7 @@ describe('Normalization', function () {
           }
           assert.strictEqual(0, min);
           assert.strictEqual(255, max);
-          return done();
+          done();
         });
     });
 
@@ -64,65 +64,49 @@ describe('Normalization', function () {
           }
           assert.strictEqual(0, min);
           assert.strictEqual(255, max);
-          return done();
+          done();
         });
     });
 
     it('keeps an existing alpha channel', function (done) {
       sharp(fixtures.inputPngWithTransparency)
         .normalize()
-        .toBuffer(function (err, data, info) {
-          sharp(data)
-            .metadata()
-            .then(function (metadata) {
-              assert.strictEqual(4, metadata.channels);
-              assert.strictEqual(true, metadata.hasAlpha);
-              assert.strictEqual('srgb', metadata.space);
-            })
-            .finally(done);
+        .toBuffer(function (err, data) {
+          if (err) return done(err);
+          sharp(data).metadata(function(err, metadata) {
+            if (err) return done(err);
+            assert.strictEqual(4, metadata.channels);
+            assert.strictEqual(true, metadata.hasAlpha);
+            assert.strictEqual('srgb', metadata.space);
+            done();
+          });
         });
     });
 
     it('keeps the alpha channel of greyscale images intact', function (done) {
       sharp(fixtures.inputPngWithGreyAlpha)
         .normalize()
-        .toBuffer(function (err, data, info) {
-          sharp(data)
-            .metadata()
-            .then(function (metadata) {
-              assert.strictEqual(true, metadata.hasAlpha);
-              assert.strictEqual(4, metadata.channels);
-              assert.strictEqual('srgb', metadata.space);
-            })
-            .finally(done);
+        .toBuffer(function (err, data) {
+          if (err) return done(err);
+          sharp(data).metadata(function(err, metadata) {
+            if (err) return done(err);
+            assert.strictEqual(true, metadata.hasAlpha);
+            assert.strictEqual(4, metadata.channels);
+            assert.strictEqual('srgb', metadata.space);
+            done();
+          });
         });
     });
 
-    it('returns a black image for images with only one color', function (done) {
+    it('does not alter images with only one color', function (done) {
+      var output = fixtures.path('output.unmodified-png-with-one-color.png');
       sharp(fixtures.inputPngWithOneColor)
         .normalize()
-        .toBuffer()
-        .bind({})
-        .then(function (imageData) {
-          this.imageData = imageData;
-          return sharp(imageData)
-            .metadata();
-        })
-        .then(function (metadata) {
-          assert.strictEqual(false, metadata.hasAlpha);
-          assert.strictEqual(3, metadata.channels);
-          assert.strictEqual('srgb', metadata.space);
-        })
-        .then(function () {
-          return sharp(this.imageData)
-            .raw()
-            .toBuffer();
-        })
-        .then(function (rawData) {
-          var blackBuffer = new Buffer([0,0,0, 0,0,0, 0,0,0, 0,0,0]);
-          assert.strictEqual(blackBuffer.toString(), rawData.toString());
-        })
-        .finally(done);
+        .toFile(output, function(err, info) {
+          if (err) done(err);
+          fixtures.assertMaxColourDistance(output, fixtures.inputPngWithOneColor, 0);
+          done();
+        });
     });
 
   }

test/unit/overlay.js

@@ -0,0 +1,175 @@
+'use strict';
+
+var assert = require('assert');
+var fixtures = require('../fixtures');
+var sharp = require('../../index');
+
+sharp.cache(0);
+
+// Helpers
+var getPaths = function(baseName, extension) {
+  if (typeof extension === 'undefined') {
+    extension = 'png';
+  }
+  return {
+    actual: fixtures.path('output.' + baseName + '.' + extension),
+    expected: fixtures.expected(baseName + '.' + extension),
+  };
+};
+
+// Test
+describe('Overlays', function() {
+  it('Overlay transparent PNG on solid background', function(done) {
+    var paths = getPaths('alpha-layer-01');
+
+    sharp(fixtures.inputPngOverlayLayer0)
+      .overlayWith(fixtures.inputPngOverlayLayer1)
+      .toFile(paths.actual, function (error) {
+        if (error) return done(error);
+        fixtures.assertMaxColourDistance(paths.actual, paths.expected);
+        done();
+      });
+  });
+
+  it('Overlay low-alpha transparent PNG on solid background', function(done) {
+    var paths = getPaths('alpha-layer-01-low-alpha');
+
+    sharp(fixtures.inputPngOverlayLayer0)
+      .overlayWith(fixtures.inputPngOverlayLayer1LowAlpha)
+      .toFile(paths.actual, function (error) {
+        if (error) return done(error);
+        fixtures.assertMaxColourDistance(paths.actual, paths.expected);
+        done();
+      });
+  });
+
+  it('Composite three transparent PNGs into one', function(done) {
+    var paths = getPaths('alpha-layer-012');
+
+    sharp(fixtures.inputPngOverlayLayer0)
+      .overlayWith(fixtures.inputPngOverlayLayer1)
+      .toBuffer(function (error, data) {
+        if (error) return done(error);
+        sharp(data)
+          .overlayWith(fixtures.inputPngOverlayLayer2)
+          .toFile(paths.actual, function (error) {
+            if (error) return done(error);
+            fixtures.assertMaxColourDistance(paths.actual, paths.expected);
+            done();
+          });
+      });
+  });
+
+  it('Composite two transparent PNGs into one', function(done) {
+    var paths = getPaths('alpha-layer-12');
+
+    sharp(fixtures.inputPngOverlayLayer1)
+      .overlayWith(fixtures.inputPngOverlayLayer2)
+      .toFile(paths.actual, function (error) {
+        if (error) return done(error);
+        fixtures.assertMaxColourDistance(paths.actual, paths.expected);
+        done();
+      });
+  });
+
+  it('Composite two low-alpha transparent PNGs into one', function(done) {
+    var paths = getPaths('alpha-layer-12-low-alpha');
+
+    sharp(fixtures.inputPngOverlayLayer1LowAlpha)
+      .overlayWith(fixtures.inputPngOverlayLayer2LowAlpha)
+      .toFile(paths.actual, function (error) {
+        if (error) return done(error);
+        fixtures.assertMaxColourDistance(paths.actual, paths.expected, 2);
+        done();
+      });
+  });
+
+  it('Composite three low-alpha transparent PNGs into one', function(done) {
+    var paths = getPaths('alpha-layer-012-low-alpha');
+
+    sharp(fixtures.inputPngOverlayLayer0)
+      .overlayWith(fixtures.inputPngOverlayLayer1LowAlpha)
+      .toBuffer(function (error, data) {
+        if (error) return done(error);
+
+        sharp(data)
+          .overlayWith(fixtures.inputPngOverlayLayer2LowAlpha)
+          .toFile(paths.actual, function (error) {
+            if (error) return done(error);
+            fixtures.assertMaxColourDistance(paths.actual, paths.expected);
+            done();
+          });
+      });
+  });
+
+  it('Composite rgb+alpha PNG onto JPEG', function(done) {
+    var paths = getPaths('overlay-jpeg-with-rgb', 'jpg');
+
+    sharp(fixtures.inputJpg)
+      .resize(2048, 1536)
+      .overlayWith(fixtures.inputPngOverlayLayer1)
+      .toFile(paths.actual, function(error, info) {
+        if (error) return done(error);
+        fixtures.assertMaxColourDistance(paths.actual, paths.expected, 102);
+        done();
+      });
+  });
+
+  it('Composite greyscale+alpha PNG onto JPEG', function(done) {
+    var paths = getPaths('overlay-jpeg-with-greyscale', 'jpg');
+
+    sharp(fixtures.inputJpg)
+      .resize(400, 300)
+      .overlayWith(fixtures.inputPngWithGreyAlpha)
+      .toFile(paths.actual, function(error, info) {
+        if (error) return done(error);
+        fixtures.assertMaxColourDistance(paths.actual, paths.expected, 102);
+        done();
+      });
+  });
+
+  if (sharp.format.webp.input.file) {
+    it('Composite WebP onto JPEG', function(done) {
+      var paths = getPaths('overlay-jpeg-with-webp', 'jpg');
+
+      sharp(fixtures.inputJpg)
+        .resize(300, 300)
+        .overlayWith(fixtures.inputWebPWithTransparency)
+        .toFile(paths.actual, function(error, info) {
+          if (error) return done(error);
+          fixtures.assertMaxColourDistance(paths.actual, paths.expected, 102);
+          done();
+        });
+    });
+  }
+
+  it('Fail when compositing images with different dimensions', function(done) {
+    sharp(fixtures.inputJpg)
+      .overlayWith(fixtures.inputPngWithGreyAlpha)
+      .toBuffer(function(error) {
+        assert.strictEqual(true, error instanceof Error);
+        done();
+      });
+  });
+
+  it('Fail when compositing non-PNG image', function(done) {
+    sharp(fixtures.inputPngOverlayLayer1)
+      .overlayWith(fixtures.inputJpg)
+      .toBuffer(function(error) {
+        assert.strictEqual(true, error instanceof Error);
+        done();
+      });
+  });
+
+  it('Fail with empty String parameter', function() {
+    assert.throws(function() {
+      sharp().overlayWith('');
+    });
+  });
+
+  it('Fail with non-String parameter', function() {
+    assert.throws(function() {
+      sharp().overlayWith(1);
+    });
+  });
+});

test/unit/resize.js

@@ -36,7 +36,7 @@ describe('Resize dimensions', function() {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
       assert.strictEqual('jpeg', info.format);
-      assert.strictEqual(391, info.width);
+      assert.strictEqual(392, info.width);
       assert.strictEqual(320, info.height);
       done();
     });
@@ -59,7 +59,7 @@ describe('Resize dimensions', function() {
       assert.strictEqual(true, data.length > 0);
       assert.strictEqual('jpeg', info.format);
       assert.strictEqual(3000, info.width);
-      assert.strictEqual(2449, info.height);
+      assert.strictEqual(2450, info.height);
       done();
     });
   });

test/unit/rotate.js

@@ -23,13 +23,17 @@ describe('Rotation', function() {
   it('Input image has Orientation EXIF tag but do not rotate output', function(done) {
     sharp(fixtures.inputJpgWithExif)
       .resize(320)
+      .withMetadata()
       .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(426, info.height);
-        done();
+        assert.strictEqual(427, info.height);
+        sharp(data).metadata(function(err, metadata) {
+          assert.strictEqual(8, metadata.orientation);
+          done();
+        });
       });
   });
 
@@ -37,12 +41,29 @@ describe('Rotation', function() {
     sharp(fixtures.inputJpgWithExif)
       .rotate()
       .resize(320)
-      .toFile(fixtures.path('output.exif.8.jpg'), function(err, info) {
+      .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();
+        fixtures.assertSimilar(fixtures.expected('exif-8.jpg'), data, done);
+      });
+  });
+
+  it('Override EXIF Orientation tag metadata after auto-rotate', function(done) {
+    sharp(fixtures.inputJpgWithExif)
+      .rotate()
+      .resize(320)
+      .withMetadata({orientation: 3})
+      .toBuffer(function(err, data, info) {
+        if (err) throw err;
+        assert.strictEqual('jpeg', info.format);
+        assert.strictEqual(320, info.width);
+        assert.strictEqual(240, info.height);
+        sharp(data).metadata(function(err, metadata) {
+          assert.strictEqual(3, metadata.orientation);
+          fixtures.assertSimilar(fixtures.expected('exif-8.jpg'), data, done);
+        });
       });
   });
 
@@ -50,12 +71,16 @@ describe('Rotation', function() {
     sharp(fixtures.inputJpgWithExifMirroring)
       .rotate()
       .resize(320)
-      .toFile(fixtures.path('output.exif.5.jpg'), function(err, info) {
+      .withMetadata()
+      .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();
+        sharp(data).metadata(function(err, metadata) {
+          assert.strictEqual(false, 'orientation' in metadata);
+          fixtures.assertSimilar(fixtures.expected('exif-5.jpg'), data, done);
+        });
       });
   });
 
@@ -85,26 +110,27 @@ describe('Rotation', function() {
       });
   });
 
-  it('Rotate to an invalid angle, should fail', function(done) {
-    var fail = false;
-    try {
+  it('Rotate to an invalid angle, should fail', function() {
+    assert.throws(function() {
       sharp(fixtures.inputJpg).rotate(1);
-      fail = true;
-    } catch (e) {}
-    assert(!fail);
-    done();
+    });
   });
 
   it('Flip - vertical', function(done) {
     sharp(fixtures.inputJpg)
       .resize(320)
       .flip()
-      .toFile(fixtures.path('output.flip.jpg'), function(err, info) {
+      .withMetadata()
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(261, info.height);
-        done();
+        sharp(data).metadata(function(err, metadata) {
+          if (err) throw err;
+          assert.strictEqual(false, 'orientation' in metadata);
+          fixtures.assertSimilar(fixtures.expected('flip.jpg'), data, done);
+        });
       });
   });
 
@@ -112,12 +138,17 @@ describe('Rotation', function() {
     sharp(fixtures.inputJpg)
       .resize(320)
       .flop()
-      .toFile(fixtures.path('output.flop.jpg'), function(err, info) {
+      .withMetadata()
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(261, info.height);
-        done();
+        sharp(data).metadata(function(err, metadata) {
+          if (err) throw err;
+          assert.strictEqual(false, 'orientation' in metadata);
+          fixtures.assertSimilar(fixtures.expected('flop.jpg'), data, done);
+        });
       });
   });
 
@@ -125,12 +156,12 @@ describe('Rotation', function() {
     sharp(fixtures.inputJpg)
       .resize(320)
       .flop()
-      .toFile(fixtures.path('output.flip.flop.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(261, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.expected('flip-and-flop.jpg'), data, done);
       });
   });
 
@@ -139,12 +170,12 @@ describe('Rotation', function() {
       .resize(320)
       .flip(false)
       .flop(false)
-      .toFile(fixtures.path('output.flip.flop.nope.jpg'), function(err, info) {
+      .toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(261, info.height);
-        done();
+        fixtures.assertSimilar(fixtures.inputJpg, data, done);
       });
   });
 

test/unit/util.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var assert = require('assert');
+var fixtures = require('../fixtures');
 var sharp = require('../../index');
 
 var defaultConcurrency = sharp.concurrency();