Improve Stream error handling #88

Output format may be derived from input format

.gitignore

@@ -13,3 +13,4 @@ results
 build
 node_modules
 tests/fixtures/output.*
+tests/libvips.supp

README.md

@@ -5,6 +5,7 @@
 * [API](https://github.com/lovell/sharp#api)
 * [Testing](https://github.com/lovell/sharp#testing)
 * [Performance](https://github.com/lovell/sharp#performance)
+* [Thanks](https://github.com/lovell/sharp#thanks)
 * [Licence](https://github.com/lovell/sharp#licence)
 
 The typical use case for this high speed Node.js module is to convert large images of many formats to smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
@@ -54,7 +55,7 @@ The _gettext_ dependency of _libvips_ [can lead](https://github.com/lovell/sharp
 
 Compiling from source is recommended:
 
-	sudo apt-get install automake build-essential git gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-turbo8-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libxml2-dev swig
+	sudo apt-get install automake build-essential git gobject-introspection gtk-doc-tools libglib2.0-dev libjpeg-turbo8-dev libpng12-dev libwebp-dev libtiff5-dev libexif-dev libxml2-dev swig libmagickwand-dev
 	git clone https://github.com/jcupitt/libvips.git
 	cd libvips
 	git checkout 7.38
@@ -74,6 +75,25 @@ Requires `libtiff4-dev` instead of `libtiff5-dev` and has [a bug](https://bugs.l
 
 Then follow Ubuntu 13.x instructions.
 
+### Install libvips on Redhat/Centos Linux
+
+#### Centos 6
+
+	sudo yum groupinstall -y "Development Tools"
+	sudo yum install -y gtk-doc libxml2-devel libjpeg-turbo-devel libpng-devel libtiff-devel libexif-devel ImageMagick-devel
+	sudo yum install -y http://li.nux.ro/download/nux/dextop/el6/x86_64/nux-dextop-release-0-2.el6.nux.noarch.rpm
+	sudo yum install -y --enablerepo=nux-dextop gobject-introspection-devel
+	sudo yum install -y http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
+	sudo yum install -y --enablerepo=remi libwebp-devel
+	git clone https://github.com/jcupitt/libvips.git
+	cd libvips
+	git checkout 7.40
+	./bootstrap.sh
+	./configure --prefix=/usr --enable-docs=no --enable-debug=no --enable-cxx=yes --without-orc --without-python --without-fftw
+	make
+	sudo make install
+	sudo ldconfig
+
 ### Install libvips on Heroku
 
 [Alessandro Tagliapietra](https://github.com/alex88) maintains an [Heroku buildpack for libvips](https://github.com/alex88/heroku-buildpack-vips) and its dependencies.
@@ -130,12 +150,13 @@ sharp('input.png')
   .rotate(180)
   .resize(300)
   .sharpen()
+  .withMetadata()
   .quality(90)
   .webp()
   .toBuffer()
   .then(function(outputBuffer) {
     // outputBuffer contains 300px wide, upside down, sharpened,
-    // 90% quality WebP image data
+    // with metadata, 90% quality WebP image data
   });
 ```
 
@@ -270,30 +291,25 @@ Use the given interpolator for image resizing, where `interpolator` is an attrib
 
 Possible interpolators, in order of performance, are:
 
-* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), the default (and fastest) interpolation.
+* `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" when enlarging and 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.
+
 ### Output options
 
-#### progressive()
-
-Use progressive (interlace) scan for JPEG and PNG output. This typically reduces compression performance by 30% but results in an image that can be rendered sooner when decompressed.
-
-#### quality(quality)
-
-The output quality to use for lossy JPEG, WebP and TIFF output formats. The default quality is `80`.
-
-`quality` is a Number between 1 and 100.
-
-#### compressionLevel(compressionLevel)
-
-An advanced setting for the _zlib_ compression level of the lossless PNG output format. The default level is `6`.
-
-`compressionLevel` is a Number between -1 and 9.
-
 #### jpeg()
 
 Use JPEG format for the output image.
@@ -306,6 +322,26 @@ Use PNG format for the output image.
 
 Use WebP format for the output image.
 
+#### quality(quality)
+
+The output quality to use for lossy JPEG, WebP and TIFF output formats. The default quality is `80`.
+
+`quality` is a Number between 1 and 100.
+
+#### progressive()
+
+Use progressive (interlace) scan for JPEG and PNG output. This typically reduces compression performance by 30% but results in an image that can be rendered sooner when decompressed.
+
+#### withMetadata([boolean])
+
+Include all metadata (ICC, EXIF, XMP) from the input image in the output image. The default behaviour is to strip all metadata.
+
+#### compressionLevel(compressionLevel)
+
+An advanced setting for the _zlib_ compression level of the lossless PNG output format. The default level is `6`.
+
+`compressionLevel` is a Number between -1 and 9.
+
 ### Output methods
 
 #### toFile(filename, [callback])
@@ -314,8 +350,8 @@ Use WebP format for the output image.
 
 `callback`, if present, is called with two arguments `(err, info)` where:
 
-* `err` contains an error message, if any
+* `err` contains an error message, if any.
-* `info` contains the final resized image dimensions in its `width` and `height` properties
+* `info` contains the output image `format`, `width` and `height`.
 
 A Promises/A+ promise is returned when `callback` is not provided.
 
@@ -325,9 +361,9 @@ Write image data to a Buffer, the format of which will match the input image by
 
 `callback`, if present, gets three arguments `(err, buffer, info)` where:
 
-* `err` is an error message, if any
+* `err` is an error message, if any.
-* `buffer` is the resultant image data
+* `buffer` is the output image data.
-* `info` contains the final resized image dimensions in its `width` and `height` properties
+* `info` contains the output image `format`, `width` and `height`.
 
 A Promises/A+ promise is returned when `callback` is not provided.
 
@@ -348,6 +384,18 @@ sharp.cache(200); // { current: 75, high: 99, memory: 200, items: 500 }
 sharp.cache(50, 200); // { current: 49, high: 99, memory: 50, items: 200}
 ```
 
+#### sharp.concurrency([threads])
+
+`threads`, if provided, is the Number of threads _libvips'_ should create for image processing. The default value is the number of CPU cores. A value of `0` will reset to this default.
+
+This method always returns the current concurrency.
+
+```javascript
+var threads = sharp.concurrency(); // 4
+sharp.concurrency(2); // 2
+sharp.concurrency(0); // 4
+```
+
 #### sharp.counters()
 
 Provides access to internal task counters.
@@ -361,16 +409,36 @@ var counters = sharp.counters(); // { queue: 2, process: 4 }
 
 ## Testing
 
-[![Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+### Ubuntu 12.04
 
-	npm test
+[![Ubuntu 12.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
 
-Running the tests requires both ImageMagick and GraphicsMagick plus one of either libmagick++-dev or libgraphicsmagick++.
+### Centos 6.5
 
-	brew install imagemagick
+[![Centos 6.5 Build Status](https://snap-ci.com/lovell/sharp/branch/master/build_image)](https://snap-ci.com/lovell/sharp/branch/master)
-	brew install graphicsmagick
 
-	sudo apt-get install imagemagick graphicsmagick libmagick++-dev
+### It worked on my machine
+
+```
+npm test
+```
+
+Running the comparative performance tests requires _ImageMagick_ and _GraphicsMagick_.
+
+```
+brew install imagemagick
+brew install graphicsmagick
+```
+
+```
+sudo apt-get install -qq imagemagick graphicsmagick
+```
+
+```
+sudo yum install ImageMagick
+sudo yum install -y http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
+sudo yum install -y --enablerepo=epel GraphicsMagick
+```
 
 ## Performance
 
@@ -411,9 +479,21 @@ Decompress a 2725x2225 JPEG image, resize and crop to 720x480, then compress to
 
 You can expect much greater performance with caching enabled (default) and using 16+ core machines.
 
+## Thanks
+
+This module would never have been possible without the help and code contributions of the following people:
+
+* [John Cupitt](https://github.com/jcupitt)
+* [Pierre Inglebert](https://github.com/pierreinglebert)
+* [Jonathan Ong](https://github.com/jonathanong)
+* [Chanon Sajjamanochai](https://github.com/chanon)
+* [Juliano Julio](https://github.com/julianojulio)
+
+Thank you!
+
 ## Licence
 
-Copyright 2013, 2014 Lovell Fuller, Pierre Inglebert, Jonathan Ong and Chanon Sajjamanochai
+Copyright 2013, 2014 Lovell Fuller and contributors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

binding.gyp

@@ -15,7 +15,9 @@
     'cflags': ['-fexceptions', '-Wall', '-O3'],
     'cflags_cc': ['-std=c++0x', '-fexceptions', '-Wall', '-O3'],
     'xcode_settings': {
-      'OTHER_CFLAGS': ['-std=c++11', '-fexceptions', '-Wall', '-O3']
+      'OTHER_CFLAGS': ['-std=c++11', '-stdlib=libc++', '-fexceptions', '-Wall', '-O3'],
+      'OTHER_CPLUSPLUSFLAGS': ['-std=c++11', '-stdlib=libc++', '-fexceptions', '-Wall', '-O3'],
+      'MACOSX_DEPLOYMENT_TARGET': '10.7'
     }
   }]
 }

index.js

@@ -20,12 +20,14 @@ var Sharp = function(input) {
     withoutEnlargement: false,
     sharpen: false,
     interpolator: 'bilinear',
+    gamma: 0,
     progressive: false,
     sequentialRead: false,
     quality: 80,
     compressionLevel: 6,
     streamIn: false,
     streamOut: false,
+    withMetadata: false,
     output: '__input'
   };
   if (typeof input === 'string') {
@@ -138,6 +140,7 @@ Sharp.prototype.sharpen = function(sharpen) {
   Set the interpolator to use for the affine transformation
 */
 module.exports.interpolator = {
+  nearest: 'nearest',
   bilinear: 'bilinear',
   bicubic: 'bicubic',
   nohalo: 'nohalo',
@@ -162,6 +165,22 @@ Sharp.prototype.nohaloInterpolation = util.deprecate(function() {
   return this.interpolateWith(module.exports.interpolator.nohalo);
 }, 'nohaloInterpolation() is deprecated, use interpolateWith(sharp.interpolator.nohalo) instead');
 
+/*
+  Darken image pre-resize (1/gamma) and brighten post-resize (gamma).
+  Improves brightness of resized image in non-linear colour spaces.
+*/
+Sharp.prototype.gamma = function(gamma) {
+  if (typeof gamma === 'undefined') {
+    // Default gamma correction of 2.2 (sRGB)
+    this.options.gamma = 2.2;
+  } else if (!Number.isNaN(gamma) && gamma >= 1 && gamma <= 3) {
+    this.options.gamma = gamma;
+  } else {
+    throw new Error('Invalid gamma correction (1.0 to 3.0) ' + gamma);
+  }
+  return this;
+};
+
 Sharp.prototype.progressive = function(progressive) {
   this.options.progressive = (typeof progressive === 'boolean') ? progressive : true;
   return this;
@@ -190,6 +209,11 @@ Sharp.prototype.compressionLevel = function(compressionLevel) {
   return this;
 };
 
+Sharp.prototype.withMetadata = function(withMetadata) {
+    this.options.withMetadata = (typeof withMetadata === 'boolean') ? withMetadata : true;
+    return this;
+};
+
 Sharp.prototype.resize = function(width, height) {
   if (!width) {
     this.options.width = -1;
@@ -307,16 +331,22 @@ Sharp.prototype._sharp = function(callback) {
       // output=stream, input=stream
       this.on('finish', function() {
         sharp.resize(that.options, function(err, data) {
-          if (err) throw err;
+          if (err) {
-          that.push(data);
+            that.emit('error', new Error(err));
+          } else {
+            that.push(data);
+          }
           that.push(null);
         });
       });
     } else {
       // output=stream, input=file/buffer
       sharp.resize(this.options, function(err, data) {
-        if (err) throw err;
+        if (err) {
-        that.push(data);
+          that.emit('error', new Error(err));
+        } else {
+          that.push(data);
+        }
         that.push(null);
       });
     }
@@ -406,6 +436,16 @@ module.exports.cache = function(memory, items) {
   return sharp.cache(memory, items);
 };
 
+/*
+  Get and set size of thread pool
+*/
+module.exports.concurrency = function(concurrency) {
+  if (Number.isNaN(concurrency)) {
+    concurrency = null;
+  }
+  return sharp.concurrency(concurrency);
+};
+
 /*
   Get internal counters
 */

package.json

@@ -1,11 +1,12 @@
 {
   "name": "sharp",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "author": "Lovell Fuller <npm@lovell.info>",
   "contributors": [
     "Pierre Inglebert <pierre.inglebert@gmail.com>",
     "Jonathan Ong <jonathanrichardong@gmail.com>",
-    "Chanon Sajjamanochai <chanon.s@gmail.com>"
+    "Chanon Sajjamanochai <chanon.s@gmail.com>",
+    "Juliano Julio <julianojulio@gmail.com>"
   ],
   "description": "High performance Node.js module to resize JPEG, PNG and WebP images using the libvips library",
   "scripts": {
@@ -35,7 +36,7 @@
   ],
   "dependencies": {
     "nan": "^1.3.0",
-    "bluebird": "^2.3.0"
+    "bluebird": "^2.3.2"
   },
   "devDependencies": {
     "imagemagick": "^0.1.3",

src/sharp.cc

@@ -16,6 +16,7 @@ struct resize_baton {
   void* buffer_in;
   size_t buffer_in_len;
   std::string output;
+  std::string output_format;
   void* buffer_out;
   size_t buffer_out_len;
   int width;
@@ -26,6 +27,7 @@ struct resize_baton {
   VipsExtend extend;
   bool sharpen;
   std::string interpolator;
+  double gamma;
   bool progressive;
   bool without_enlargement;
   VipsAccess access_method;
@@ -33,16 +35,20 @@ struct resize_baton {
   int compressionLevel;
   int angle;
   std::string err;
+  bool withMetadata;
 
   resize_baton():
     buffer_in_len(0),
+    output_format(""),
     buffer_out_len(0),
     crop(false),
     gravity(0),
     max(false),
     sharpen(false),
+    gamma(0.0),
     progressive(false),
-    without_enlargement(false) {}
+    without_enlargement(false),
+    withMetadata(false) {}
 };
 
 typedef enum {
@@ -432,9 +438,9 @@ class ResizeWorker : public NanAsyncWorker {
       }
     }
 
-    // Try to use libjpeg shrink-on-load
+    // Try to use libjpeg shrink-on-load, but not when applying gamma correction
     int shrink_on_load = 1;
-    if (inputImageType == JPEG) {
+    if (inputImageType == JPEG && baton->gamma == 0) {
       if (shrink >= 8) {
         factor = factor / 8;
         shrink_on_load = 8;
@@ -467,6 +473,16 @@ class ResizeWorker : public NanAsyncWorker {
     }
     g_object_unref(in);
 
+    // Gamma encoding (darken)
+    if (baton->gamma >= 1 && baton->gamma <= 3) {
+      VipsImage *gamma_encoded = vips_image_new();
+      if (vips_gamma(shrunk_on_load, &gamma_encoded, "exponent", 1.0 / baton->gamma, NULL)) {
+        return resize_error(baton, shrunk_on_load);
+      }
+      g_object_unref(shrunk_on_load);
+      shrunk_on_load = gamma_encoded;
+    }
+
     VipsImage *shrunk = vips_image_new();
     if (shrink > 1) {
       // Use vips_shrink with the integral reduction
@@ -565,6 +581,16 @@ class ResizeWorker : public NanAsyncWorker {
     }
     g_object_unref(canvased);
 
+    // Gamma decoding (brighten)
+    if (baton->gamma >= 1 && baton->gamma <= 3) {
+      VipsImage *gamma_decoded = vips_image_new();
+      if (vips_gamma(sharpened, &gamma_decoded, "exponent", baton->gamma, NULL)) {
+        return resize_error(baton, sharpened);
+      }
+      g_object_unref(sharpened);
+      sharpened = gamma_decoded;
+    }
+
     // Always convert to sRGB colour space
     VipsImage *colourspaced = vips_image_new();
     vips_colourspace(sharpened, &colourspaced, VIPS_INTERPRETATION_sRGB, NULL);
@@ -585,41 +611,63 @@ class ResizeWorker : public NanAsyncWorker {
     VipsImage *output = cached;
     if (baton->output == "__jpeg" || (baton->output == "__input" && inputImageType == JPEG)) {
       // Write JPEG to buffer
-      if (vips_jpegsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
+      if (vips_jpegsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", !baton->withMetadata,
+        "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
         return resize_error(baton, output);
       }
+      baton->output_format = "jpeg";
     } else if (baton->output == "__png" || (baton->output == "__input" && inputImageType == PNG)) {
       // Write PNG to buffer
-      if (vips_pngsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
+      if (vips_pngsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", !baton->withMetadata,
+        "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
         return resize_error(baton, output);
       }
+      baton->output_format = "png";
     } else if (baton->output == "__webp" || (baton->output == "__input" && inputImageType == WEBP)) {
       // Write WEBP to buffer
-      if (vips_webpsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", baton->quality, NULL)) {
+      if (vips_webpsave_buffer(output, &baton->buffer_out, &baton->buffer_out_len, "strip", !baton->withMetadata,
-        return resize_error(baton, output);
+        "Q", baton->quality, NULL)) {
-      }
-    } else if (is_jpeg(baton->output))  {
-      // Write JPEG to file
-      if (vips_jpegsave(output, baton->output.c_str(), "strip", TRUE, "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
-        return resize_error(baton, output);
-      }
-    } else if (is_png(baton->output)) {
-      // Write PNG to file
-      if (vips_pngsave(output, baton->output.c_str(), "strip", TRUE, "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
-        return resize_error(baton, output);
-      }
-    } else if (is_webp(baton->output)) {
-      // Write WEBP to file
-      if (vips_webpsave(output, baton->output.c_str(), "strip", TRUE, "Q", baton->quality, NULL)) {
-        return resize_error(baton, output);
-      }
-    } else if (is_tiff(baton->output)) {
-      // Write TIFF to file
-      if (vips_tiffsave(output, baton->output.c_str(), "strip", TRUE, "compression", VIPS_FOREIGN_TIFF_COMPRESSION_JPEG, "Q", baton->quality, NULL)) {
         return resize_error(baton, output);
       }
+      baton->output_format = "webp";
     } else {
-      (baton->err).append("Unsupported output " + baton->output);
+      bool output_jpeg = is_jpeg(baton->output);
+      bool output_png = is_png(baton->output);
+      bool output_webp = is_webp(baton->output);
+      bool output_tiff = is_tiff(baton->output);
+      bool match_input = !(output_jpeg || output_png || output_webp || output_tiff);
+      if (output_jpeg || (match_input && inputImageType == JPEG)) {
+        // Write JPEG to file
+        if (vips_jpegsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "Q", baton->quality, "optimize_coding", TRUE, "interlace", baton->progressive, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "jpeg";
+      } else if (output_png || (match_input && inputImageType == PNG)) {
+        // Write PNG to file
+        if (vips_pngsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "compression", baton->compressionLevel, "interlace", baton->progressive, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "png";
+      } else if (output_webp || (match_input && inputImageType == WEBP)) {
+        // Write WEBP to file
+        if (vips_webpsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "Q", baton->quality, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "webp";
+      } else if (output_tiff || (match_input && inputImageType == TIFF)) {
+        // Write TIFF to file
+        if (vips_tiffsave(output, baton->output.c_str(), "strip", !baton->withMetadata,
+          "compression", VIPS_FOREIGN_TIFF_COMPRESSION_JPEG, "Q", baton->quality, NULL)) {
+          return resize_error(baton, output);
+        }
+        baton->output_format = "tiff";
+      } else {
+        (baton->err).append("Unsupported output " + baton->output);
+        return resize_error(baton, output);
+      }
     }
     g_object_unref(output);
 
@@ -638,12 +686,13 @@ class ResizeWorker : public NanAsyncWorker {
     } else {
       // Info Object
       Local<Object> info = NanNew<Object>();
+      info->Set(NanNew<String>("format"), NanNew<String>(baton->output_format));
       info->Set(NanNew<String>("width"), NanNew<Number>(baton->width));
       info->Set(NanNew<String>("height"), NanNew<Number>(baton->height));
 
       if (baton->buffer_out_len > 0) {
         // Buffer
-        argv[1] = NanNewBufferHandle((char *)baton->buffer_out, baton->buffer_out_len);
+        argv[1] = NanNewBufferHandle(static_cast<char*>(baton->buffer_out), baton->buffer_out_len);
         g_free(baton->buffer_out);
         argv[2] = info;
       } else {
@@ -700,12 +749,14 @@ NAN_METHOD(resize) {
   baton->gravity = options->Get(NanNew<String>("gravity"))->Int32Value();
   baton->sharpen = options->Get(NanNew<String>("sharpen"))->BooleanValue();
   baton->interpolator = *String::Utf8Value(options->Get(NanNew<String>("interpolator"))->ToString());
+  baton->gamma = options->Get(NanNew<String>("gamma"))->NumberValue();
   baton->progressive = options->Get(NanNew<String>("progressive"))->BooleanValue();
   baton->without_enlargement = options->Get(NanNew<String>("withoutEnlargement"))->BooleanValue();
   baton->access_method = options->Get(NanNew<String>("sequentialRead"))->BooleanValue() ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
   baton->quality = options->Get(NanNew<String>("quality"))->Int32Value();
   baton->compressionLevel = options->Get(NanNew<String>("compressionLevel"))->Int32Value();
   baton->angle = options->Get(NanNew<String>("angle"))->Int32Value();
+  baton->withMetadata = options->Get(NanNew<String>("withMetadata"))->BooleanValue();
   // Output filename or __format for Buffer
   baton->output = *String::Utf8Value(options->Get(NanNew<String>("output"))->ToString());
 
@@ -727,7 +778,12 @@ NAN_METHOD(cache) {
 
   // Set cache memory limit
   if (args[0]->IsInt32()) {
-    vips_cache_set_max_mem(args[0]->Int32Value() * 1048576);
+    int newMax = args[0]->Int32Value() * 1048576;
+    int oldMax = vips_cache_get_max_mem();
+    vips_cache_set_max_mem(newMax);
+
+    // Notify the V8 garbage collector of delta in max cache size
+    NanAdjustExternalMemory(newMax - oldMax);
   }
 
   // Set cache items limit
@@ -744,6 +800,20 @@ NAN_METHOD(cache) {
   NanReturnValue(cache);
 }
 
+/*
+  Get and set size of thread pool
+*/
+NAN_METHOD(concurrency) {
+  NanScope();
+
+  // Set concurrency
+  if (args[0]->IsInt32()) {
+    vips_concurrency_set(args[0]->Int32Value());
+  }
+  // Get concurrency
+  NanReturnValue(NanNew<Number>(vips_concurrency_get()));
+}
+
 /*
   Get internal counters (queued tasks, processing tasks)
 */
@@ -762,15 +832,21 @@ static void at_exit(void* arg) {
 
 extern "C" void init(Handle<Object> target) {
   NanScope();
-  vips_init("");
+  vips_init("sharp");
   AtExit(at_exit);
+
   // Set libvips operation cache limits
   vips_cache_set_max_mem(100 * 1048576); // 100 MB
   vips_cache_set_max(500); // 500 operations
+
+  // Notify the V8 garbage collector of max cache size
+  NanAdjustExternalMemory(vips_cache_get_max_mem());
+
   // Methods available to JavaScript
   NODE_SET_METHOD(target, "metadata", metadata);
   NODE_SET_METHOD(target, "resize", resize);
   NODE_SET_METHOD(target, "cache", cache);
+  NODE_SET_METHOD(target, "concurrency", concurrency);
   NODE_SET_METHOD(target, "counters", counters);
 }
 

tests/leak.sh

@@ -0,0 +1,7 @@
+if ! type valgrind >/dev/null; then
+  echo "Please install valgrind before running memory leak tests"
+  exit 1
+fi
+
+curl -O https://raw.githubusercontent.com/jcupitt/libvips/master/libvips.supp
+G_SLICE=always-malloc G_DEBUG=gc-friendly valgrind --suppressions=libvips.supp --suppressions=sharp.supp --leak-check=full --show-leak-kinds=definite,indirect,possible node unit.js

tests/parallel.js

@@ -1,37 +1,39 @@
-var sharp = require("../index");
+var sharp = require("../index");
-var fs = require("fs");
+var fs = require("fs");
-var path = require("path");
+var path = require("path");
-var assert = require("assert");
+var assert = require("assert");
-var async = require("async");
+var async = require("async");
-
+
-var inputJpg = path.join(__dirname, "fixtures/2569067123_aca715a2ee_o.jpg"); // http://www.flickr.com/photos/grizdave/2569067123/
+var inputJpg = path.join(__dirname, "fixtures/2569067123_aca715a2ee_o.jpg"); // http://www.flickr.com/photos/grizdave/2569067123/
-var width = 720;
+var width = 720;
-var height = 480;
+var height = 480;
-
+
-var timer = setInterval(function() {
+sharp.concurrency(1);
-  console.dir(sharp.cache());
+
-}, 100);
+var timer = setInterval(function() {
-
+  console.dir(sharp.counters());
-async.mapSeries([1, 1, 2, 4, 8, 16, 32, 64, 128], function(parallelism, next) {
+}, 100);
-  var start = new Date().getTime();
+
-  async.times(parallelism,
+async.mapSeries([1, 1, 2, 4, 8, 16, 32, 64, 128], function(parallelism, next) {
-    function(id, callback) {
+  var start = new Date().getTime();
-      sharp(inputJpg).resize(width, height).toBuffer(function(err, buffer) {
+  async.times(parallelism,
-        buffer = null;
+    function(id, callback) {
-        callback(err, new Date().getTime() - start);
+      sharp(inputJpg).resize(width, height).toBuffer(function(err, buffer) {
-      });
+        buffer = null;
-    },
+        callback(err, new Date().getTime() - start);
-    function(err, ids) {
+      });
-      assert(!err);
+    },
-      assert(ids.length === parallelism);
+    function(err, ids) {
-      var mean = ids.reduce(function(a, b) {
+      assert(!err);
-        return a + b;
+      assert(ids.length === parallelism);
-      }) / ids.length;
+      var mean = ids.reduce(function(a, b) {
-      console.log(parallelism + " parallel calls: fastest=" + ids[0] + "ms slowest=" + ids[ids.length - 1] + "ms mean=" + mean + "ms");
+        return a + b;
-      next();
+      }) / ids.length;
-    }
+      console.log(parallelism + " parallel calls: fastest=" + ids[0] + "ms slowest=" + ids[ids.length - 1] + "ms mean=" + mean + "ms");
-  );
+      next();
-}, function() {
+    }
-  clearInterval(timer);
+  );
-  console.dir(sharp.cache());
+}, function() {
-});
+  clearInterval(timer);
+  console.dir(sharp.counters());
+});

tests/perf.js

@@ -185,6 +185,18 @@ async.series({
           }
         });
       }
+    }).add("sharp-file-buffer-nearest-neighbour", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).interpolateWith(sharp.interpolator.nearest).toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
     }).add("sharp-file-buffer-bicubic", {
       defer: true,
       fn: function(deferred) {
@@ -233,6 +245,18 @@ async.series({
           }
         });
       }
+    }).add("sharp-file-buffer-gamma", {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpg).resize(width, height).gamma().toBuffer(function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
     }).add("sharp-file-buffer-progressive", {
       defer: true,
       fn: function(deferred) {

tests/sharp.supp

@@ -0,0 +1,111 @@
+# libjpeg warnings
+{
+  cond_jpeg_read_scanlines
+  Memcheck:Cond
+  ...
+  fun:jpeg_read_scanlines
+}
+{
+  value_jpeg_read_scanlines
+  Memcheck:Value8
+  ...
+  fun:jpeg_read_scanlines
+}
+{
+  cond_jpeg_write_scanlines
+  Memcheck:Cond
+  ...
+  fun:jpeg_write_scanlines
+}
+{
+  cond_jpeg_finish_compress
+  Memcheck:Cond
+  ...
+  fun:jpeg_finish_compress
+}
+{
+  value_jpeg_finish_compress
+  Memcheck:Value8
+  ...
+  fun:jpeg_finish_compress
+}
+
+# libvips interpolator warnings
+{
+  cond_libvips_interpolate_lbb
+  Memcheck:Cond
+  ...
+  fun:_ZL32vips_interpolate_lbb_interpolateP16_VipsInterpolatePvP11_VipsRegiondd
+  fun:vips_affine_gen
+}
+
+# libuv warnings
+{
+  free_libuv
+  Memcheck:Free
+  ...
+  fun:uv__work_done
+}
+
+# nodejs warnings
+{
+  param_nodejs_write_buffer
+  Memcheck:Param
+  write(buf)
+  ...
+  obj:/usr/bin/nodejs
+}
+{
+  leak_nodejs_ImmutableAsciiSource_CreateFromLiteral
+  Memcheck:Leak
+  match-leak-kinds: definite
+  ...
+  fun:_ZN4node20ImmutableAsciiSource17CreateFromLiteralEPKcm
+}
+{
+  leak_nodejs_Buffer_New
+  Memcheck:Leak
+  match-leak-kinds: definite
+  ...
+  fun:_ZN4node6Buffer3NewERKN2v89ArgumentsE
+}
+{
+  leak_nodejs_Buffer_Replace
+   Memcheck:Leak
+   match-leak-kinds: indirect,possible
+   ...
+   fun:_ZN4node6Buffer7ReplaceEPcmPFvS1_PvES2_
+}
+{
+  leak_nodejs_SignalWrap_New
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node10SignalWrap3NewERKN2v89ArgumentsE
+}
+{
+  leak_nodejs_TTYWrap_New
+  Memcheck:Leak
+  match-leak-kinds: possible
+  ...
+  fun:_ZN4node7TTYWrap3NewERKN2v89ArgumentsE
+}
+{
+  leak_nodejs_ares_init_options
+  Memcheck:Leak
+  match-leak-kinds: reachable
+  fun:malloc
+  fun:strdup
+  ...
+  fun:ares_init_options
+}
+
+# vips__init warnings
+{
+  leak_libvips_init
+  Memcheck:Leak
+  match-leak-kinds: reachable
+  fun:malloc
+  ...
+  fun:vips__init
+}

tests/unit.js

@@ -18,20 +18,30 @@ var outputTiff = path.join(fixturesPath, "output.tiff");
 
 var inputJpgWithExif = path.join(fixturesPath, "Landscape_8.jpg"); // https://github.com/recurser/exif-orientation-examples/blob/master/Landscape_8.jpg
 
+var inputJpgWithGammaHoliness = path.join(fixturesPath, "gamma_dalai_lama_gray.jpg"); // http://www.4p8.com/eric.brasseur/gamma.html
+
 var inputPng = path.join(fixturesPath, "50020484-00001.png"); // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
-var inputWebp = path.join(fixturesPath, "4.webp"); // http://www.gstatic.com/webp/gallery/4.webp
+var inputWebP = path.join(fixturesPath, "4.webp"); // http://www.gstatic.com/webp/gallery/4.webp
 var inputGif = path.join(fixturesPath, "Crash_test.gif"); // http://upload.wikimedia.org/wikipedia/commons/e/e3/Crash_test.gif
 
 // Ensure cache limits can be set
 sharp.cache(0); // Disable
 sharp.cache(50, 500); // 50MB, 500 items
 
+// Ensure concurrency can be set
+var defaultConcurrency = sharp.concurrency();
+sharp.concurrency(16);
+assert.strictEqual(16, sharp.concurrency());
+sharp.concurrency(0);
+assert.strictEqual(defaultConcurrency, sharp.concurrency());
+
 async.series([
   // Resize with exact crop
   function(done) {
     sharp(inputJpg).resize(320, 240).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -42,6 +52,7 @@ async.series([
     sharp(inputJpg).resize(320).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(261, info.height);
       done();
@@ -52,6 +63,7 @@ async.series([
     sharp(inputJpg).resize(null, 320).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(391, info.width);
       assert.strictEqual(320, info.height);
       done();
@@ -62,6 +74,7 @@ async.series([
     sharp(inputJpg).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(2725, info.width);
       assert.strictEqual(2225, info.height);
       done();
@@ -72,6 +85,7 @@ async.series([
     sharp(inputJpg).resize(3000).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(3000, info.width);
       assert.strictEqual(2449, info.height);
       done();
@@ -96,6 +110,7 @@ async.series([
     sharp(inputTiff).resize(240, 320).embedBlack().jpeg().toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(240, info.width);
       assert.strictEqual(320, info.height);
       done();
@@ -105,6 +120,7 @@ async.series([
     sharp(inputTiff).resize(240, 320).jpeg().toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(240, info.width);
       assert.strictEqual(320, info.height);
       done();
@@ -115,6 +131,7 @@ async.series([
     sharp(inputJpg).resize(320, 320).max().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(261, info.height);
       done();
@@ -125,6 +142,7 @@ async.series([
     sharp(inputTiff).resize(320, 320).max().jpeg().toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(243, info.width);
       assert.strictEqual(320, info.height);
       done();
@@ -135,6 +153,7 @@ async.series([
     sharp(inputJpg).resize(320).max().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(261, info.height);
       done();
@@ -152,6 +171,7 @@ async.series([
     sharp(inputJpg).rotate(90).resize(320, 240).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -162,6 +182,7 @@ async.series([
     sharp(inputJpgWithExif).resize(320).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();
@@ -172,6 +193,7 @@ async.series([
     sharp(inputJpgWithExif).rotate().resize(320).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -182,6 +204,7 @@ async.series([
     sharp(inputJpg).rotate().resize(320).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(261, info.height);
       done();
@@ -202,6 +225,7 @@ async.series([
     sharp(inputJpg).resize(2800).withoutEnlargement().toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(2725, info.width);
       assert.strictEqual(2225, info.height);
       done();
@@ -212,6 +236,7 @@ async.series([
     sharp(inputJpg).resize(null, 2300).withoutEnlargement().toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(2725, info.width);
       assert.strictEqual(2225, info.height);
       done();
@@ -223,6 +248,7 @@ async.series([
       sharp(data).toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
+        assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
         done();
@@ -243,7 +269,20 @@ async.series([
   },
   // Check colour space conversion occurs from TIFF to WebP (this used to segfault)
   function(done) {
-    sharp(inputTiff).webp().toBuffer().then(function() {
+    sharp(inputTiff).webp().toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual('webp', info.format);
+      done();
+    });
+  },
+  // Interpolation: nearest neighbour
+  function(done) {
+    sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.nearest).toBuffer(function(err, data, info) {
+      if (err) throw err;
+      assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(240, info.height);
       done();
     });
   },
@@ -252,6 +291,7 @@ async.series([
     sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.bilinear).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -262,6 +302,7 @@ async.series([
     sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.bicubic).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -272,6 +313,7 @@ async.series([
     sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.nohalo).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -282,6 +324,7 @@ async.series([
     sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.locallyBoundedBicubic).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -292,6 +335,7 @@ async.series([
     sharp(inputJpg).resize(320, 240).interpolateWith(sharp.interpolator.vertexSplitQuadraticBasisSpline).toBuffer(function(err, data, info) {
       if (err) throw err;
       assert.strictEqual(true, data.length > 0);
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -304,6 +348,7 @@ async.series([
       sharp(outputJpg).toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
+        assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
         fs.unlinkSync(outputJpg);
@@ -320,6 +365,7 @@ async.series([
       sharp(outputJpg).toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
+        assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
         fs.unlinkSync(outputJpg);
@@ -333,6 +379,7 @@ async.series([
     var readable = fs.createReadStream(inputJpg);
     var pipeline = sharp().resize(320, 240).toFile(outputJpg, function(err, info) {
       if (err) throw err;
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       fs.unlinkSync(outputJpg);
@@ -345,6 +392,7 @@ async.series([
     var readable = fs.createReadStream(inputJpg);
     var pipeline = sharp().resize(320, 240).toBuffer(function(err, data, info) {
       if (err) throw err;
+      assert.strictEqual('jpeg', info.format);
       assert.strictEqual(320, info.width);
       assert.strictEqual(240, info.height);
       done();
@@ -359,6 +407,7 @@ async.series([
       sharp(outputJpg).toBuffer(function(err, data, info) {
         if (err) throw err;
         assert.strictEqual(true, data.length > 0);
+        assert.strictEqual('jpeg', info.format);
         assert.strictEqual(320, info.width);
         assert.strictEqual(240, info.height);
         fs.unlinkSync(outputJpg);
@@ -368,6 +417,33 @@ async.series([
     var pipeline = sharp().resize(320, 240);
     readable.pipe(pipeline).pipe(writable);
   },
+  // Stream-Stream error handling
+  function(done) {
+    var pipeline = sharp().resize(320, 240);
+    var anErrorWasEmitted = false;
+    pipeline.on('error', function(err) {
+      anErrorWasEmitted = !!err;
+    }).on('end', function() {
+      assert(anErrorWasEmitted);
+      done();
+    });
+    var readableButNotAnImage = fs.createReadStream(__filename);
+    var writable = fs.createWriteStream(outputJpg);
+    readableButNotAnImage.pipe(pipeline).pipe(writable);
+  },
+  // File-Stream error handling
+  function(done) {
+    var readableButNotAnImage = sharp(__filename).resize(320, 240);
+    var anErrorWasEmitted = false;
+    readableButNotAnImage.on('error', function(err) {
+      anErrorWasEmitted = !!err;
+    }).on('end', function() {
+      assert(anErrorWasEmitted);
+      done();
+    });
+    var writable = fs.createWriteStream(outputJpg);
+    readableButNotAnImage.pipe(writable);
+  },
   // Crop, gravity=north
   function(done) {
     sharp(inputJpg).resize(320, 80).crop(sharp.gravity.north).toFile(path.join(fixturesPath, 'output.gravity-north.jpg'), function(err, info) {
@@ -422,6 +498,70 @@ async.series([
       done();
     });
   },
+  // Keeps Metadata after a resize
+  function(done) {
+      sharp(inputJpgWithExif).resize(320, 240).withMetadata().toBuffer(function(err, buffer) {
+          if (err) throw err;
+          sharp(buffer).metadata(function(err, metadata) {
+              if (err) throw err;
+              assert.strictEqual(8, metadata.orientation);
+              done();
+          });
+      });
+  },
+  // Keeps Metadata after a resize
+  function(done) {
+      sharp(inputJpgWithExif).resize(320, 240).withMetadata(false).toBuffer(function(err, buffer) {
+          if (err) throw err;
+          sharp(buffer).metadata(function(err, metadata) {
+              if (err) throw err;
+              assert.strictEqual('undefined', typeof metadata.orientation);
+              done();
+          });
+      });
+  },
+  // Output filename without extension should mirror input format
+  function(done) {
+    sharp(inputJpg).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('jpeg', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputPng).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('png', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputWebP).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('webp', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputTiff).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      if (err) throw err;
+      assert.strictEqual('tiff', info.format);
+      assert.strictEqual(320, info.width);
+      assert.strictEqual(80, info.height);
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputGif).resize(320, 80).toFile(path.join(fixturesPath, 'output.zoinks'), function(err, info) {
+      assert(!!err);
+    });
+  },
   // Metadata - JPEG
   function(done) {
     sharp(inputJpg).metadata(function(err, metadata) {
@@ -474,7 +614,7 @@ async.series([
   },
   // Metadata - WebP
   function(done) {
-    sharp(inputWebp).metadata(function(err, metadata) {
+    sharp(inputWebP).metadata(function(err, metadata) {
       if (err) throw err;
       assert.strictEqual('webp', metadata.format);
       assert.strictEqual(1024, metadata.width);
@@ -539,6 +679,25 @@ async.series([
       });
     });
   },
+  // Gamma correction
+  function(done) {
+    sharp(inputJpgWithGammaHoliness).resize(129, 111).toFile(path.join(fixturesPath, 'output.gamma-0.0.jpg'), function(err) {
+      if (err) throw err;
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputJpgWithGammaHoliness).resize(129, 111).gamma().toFile(path.join(fixturesPath, 'output.gamma-2.2.jpg'), function(err) {
+      if (err) throw err;
+      done();
+    });
+  },
+  function(done) {
+    sharp(inputJpgWithGammaHoliness).resize(129, 111).gamma(3).toFile(path.join(fixturesPath, 'output.gamma-3.0.jpg'), function(err) {
+      if (err) throw err;
+      done();
+    });
+  },
   // Verify internal counters
   function(done) {
     var counters = sharp.counters();