Provide a default lib location when detecting C++11 ABI

Useful for pkgconfig without -L, e.g. Alpine Linux
See also commit 07d66da

.gitignore

@@ -4,8 +4,13 @@ coverage
 test/bench/node_modules
 test/fixtures/output*
 test/leak/libvips.supp
+test/saliency/report.json
+test/saliency/Image*
+test/saliency/[Uu]serData*
+!test/saliency/userData.js
 lib
 include
 packaging/libvips*
 packaging/*.log
+!packaging/build
 .DS_Store

.jshintignore

@@ -1,3 +1,4 @@
 node_modules
 test/bench/node_modules
+test/saliency/humanae/node_modules
 coverage

.jshintrc

@@ -2,7 +2,7 @@
   "strict": true,
   "node": true,
   "maxparams": 4,
-  "maxcomplexity": 13,
+  "maxcomplexity": 14,
   "globals": {
     "beforeEach": true,
     "afterEach": true,

.npmignore

@@ -13,3 +13,4 @@ mkdocs.yml
 lib
 include
 packaging
+preinstall.sh

.travis.yml

@@ -3,7 +3,7 @@ node_js:
   - "0.10"
   - "0.12"
   - "4"
-  - "5"
+  - "6"
 os:
   - linux
   - osx
@@ -14,9 +14,8 @@ addons:
     - ubuntu-toolchain-r-test
     packages:
     - g++-4.8
-osx_image: xcode7.3
+osx_image: xcode8
 before_install:
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export CXX=g++-4.8; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install homebrew/science/vips; fi
 after_success:
   - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js

CONTRIBUTING.md

@@ -41,9 +41,9 @@ Any change that modifies the existing public API should be added to the relevant
 
 | Release | WIP branch |
 | ------: | :--------- |
-| v0.15.0 | outfit     |
 | v0.16.0 | pencil     |
 | v0.17.0 | quill      |
+| v0.18.0 | ridge      |
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
 

README.md

@@ -1,23 +1,61 @@
 # sharp
 
+```sh
+npm install sharp
+```
+
 The typical use case for this high speed Node.js module
-is to convert large images of many formats to
+is to convert large images in common formats to
 smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
 
-Resizing an image is typically 4x faster than using the
+Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings.
 
 Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
-Bicubic interpolation with Lanczos anti-alias filtering ensures quality is not sacrificed for speed.
+Lanczos resampling ensures quality is not sacrificed for speed.
 
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most Windows (x64), Linux and ARMv6+ systems do not require
+OS X, Windows (x64), Linux (x64, ARM) systems do not require
 the installation of any external runtime dependencies.
 
-Use with OS X is as simple as running `brew install homebrew/science/vips`
-to install the libvips dependency.
+## Examples
+
+```javascript
+import sharp from 'sharp';
+```
+
+```javascript
+sharp(inputBuffer)
+  .resize(320, 240)
+  .toFile('output.webp', (err, info) => ... );
+```
+
+```javascript
+sharp('input.jpg')
+  .rotate()
+  .resize(200)
+  .toBuffer()
+  .then( data => ... )
+  .catch( err => ... );
+```
+
+```javascript
+const roundedCorners = new Buffer(
+  '<svg><rect x="0" y="0" width="200" height="200" rx="50" ry="50"/></svg>'
+);
+
+const roundedCornerResizer =
+  sharp()
+    .resize(200, 200)
+    .overlayWith(roundedCorners, { cutout: true })
+    .png();
+
+readableStream
+  .pipe(roundedCornerResizer)
+  .pipe(writableStream);
+```
 
 [![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.png?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
 

appveyor.yml

@@ -7,9 +7,10 @@ environment:
   matrix:
   - nodejs_version: "0.12"
   - nodejs_version: "4"
-  - nodejs_version: "5"
+  - nodejs_version: "6"
 install:
   - ps: Install-Product node $env:nodejs_version x64
+  - npm install -g npm@latest
   - npm install
 test_script:
   - npm run-script test-win

binding.gyp

@@ -9,7 +9,8 @@
           'download_vips': '<!(node -e "require(\'./binding\').download_vips()")'
         },
         'defines': [
-          'VIPS_CPLUSPLUS_EXPORTS'
+          'VIPS_CPLUSPLUS_EXPORTS',
+          '_ALLOW_KEYWORD_MACROS'
         ],
         'sources': [
           'src/libvips/cplusplus/VError.cpp',
@@ -17,14 +18,14 @@
           'src/libvips/cplusplus/VImage.cpp'
         ],
         'include_dirs': [
-          '<(module_root_dir)/include',
-          '<(module_root_dir)/include/glib-2.0',
-          '<(module_root_dir)/lib/glib-2.0/include'
+          'include',
+          'include/glib-2.0',
+          'lib/glib-2.0/include'
         ],
         'libraries': [
-          '<(module_root_dir)/lib/libvips.lib',
-          '<(module_root_dir)/lib/libglib-2.0.lib',
-          '<(module_root_dir)/lib/libgobject-2.0.lib'
+          '../lib/libvips.lib',
+          '../lib/libglib-2.0.lib',
+          '../lib/libgobject-2.0.lib'
         ],
         'configurations': {
           'Release': {
@@ -90,9 +91,6 @@
       'src/sharp.cc',
       'src/utilities.cc'
     ],
-    'defines': [
-      '_GLIBCXX_USE_CXX11_ABI=0'
-    ],
     'include_dirs': [
       '<!(node -e "require(\'nan\')")'
     ],
@@ -106,51 +104,83 @@
           }, {
             'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs vips-cpp)']
           }]
+        ],
+        'defines': [
+          # Inspect libvips-cpp.so to determine which C++11 ABI version was used and set _GLIBCXX_USE_CXX11_ABI accordingly. This is quite horrible.
+          '_GLIBCXX_USE_CXX11_ABI=<!(if readelf -Ws "$(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs-only-L vips-cpp | cut -c 3- | sed -e "s/^$/\/usr\/lib/")/libvips-cpp.so" | c++filt | grep -qF __cxx11;then echo "1";else echo "0";fi)'
         ]
       }, {
         # Attempt to download pre-built libvips and install locally within node_modules
         'include_dirs': [
-          '<(module_root_dir)/include',
-          '<(module_root_dir)/include/glib-2.0',
-          '<(module_root_dir)/lib/glib-2.0/include'
+          'include',
+          'include/glib-2.0',
+          'lib/glib-2.0/include'
         ],
         'conditions': [
           ['OS == "win"', {
+            'defines': [
+              '_ALLOW_KEYWORD_MACROS'
+            ],
             'libraries': [
-              '<(module_root_dir)/lib/libvips.lib',
-              '<(module_root_dir)/lib/libglib-2.0.lib',
-              '<(module_root_dir)/lib/libgobject-2.0.lib'
+              '../lib/libvips.lib',
+              '../lib/libglib-2.0.lib',
+              '../lib/libgobject-2.0.lib'
+            ]
+          }],
+          ['OS == "mac"', {
+            'variables': {
+              'download_vips': '<!(node -e "require(\'./binding\').download_vips()")'
+            },
+            'libraries': [
+              '../lib/libvips-cpp.42.dylib',
+              '../lib/libvips.42.dylib',
+              '../lib/libglib-2.0.0.dylib',
+              '../lib/libgobject-2.0.0.dylib',
+              # Ensure runtime linking is relative to sharp.node
+              '-rpath \'@loader_path/../../lib\''
             ]
           }],
           ['OS == "linux"', {
             'variables': {
               'download_vips': '<!(LDD_VERSION="<!(ldd --version 2>&1 || true)" node -e "require(\'./binding\').download_vips()")'
             },
+            'defines': [
+              '_GLIBCXX_USE_CXX11_ABI=0'
+            ],
             'libraries': [
-              '<(module_root_dir)/lib/libvips-cpp.so',
-              '<(module_root_dir)/lib/libvips.so',
-              '<(module_root_dir)/lib/libglib-2.0.so',
-              '<(module_root_dir)/lib/libgobject-2.0.so',
+              '../lib/libvips-cpp.so',
+              '../lib/libvips.so',
+              '../lib/libglib-2.0.so',
+              '../lib/libgobject-2.0.so',
               # Dependencies of dependencies, included for openSUSE support
-              '<(module_root_dir)/lib/libGraphicsMagick.so',
-              '<(module_root_dir)/lib/libGraphicsMagickWand.so',
-              '<(module_root_dir)/lib/libexif.so',
-              '<(module_root_dir)/lib/libgio-2.0.so',
-              '<(module_root_dir)/lib/libgmodule-2.0.so',
-              '<(module_root_dir)/lib/libgsf-1.so',
-              '<(module_root_dir)/lib/libjpeg.so',
-              '<(module_root_dir)/lib/libpng.so',
-              '<(module_root_dir)/lib/libtiff.so',
-              '<(module_root_dir)/lib/libwebp.so',
-              '<(module_root_dir)/lib/libz.so',
-              '<(module_root_dir)/lib/libffi.so',
-              '<(module_root_dir)/lib/libgthread-2.0.so',
-              '<(module_root_dir)/lib/liblcms2.so',
-              '<(module_root_dir)/lib/libpng16.so',
-              '<(module_root_dir)/lib/libxml2.so',
-              '<(module_root_dir)/lib/liborc-0.4.so',
+              '../lib/libcairo.so',
+              '../lib/libcroco-0.6.so',
+              '../lib/libexif.so',
+              '../lib/libffi.so',
+              '../lib/libfontconfig.so',
+              '../lib/libfreetype.so',
+              '../lib/libgdk_pixbuf-2.0.so',
+              '../lib/libgif.so',
+              '../lib/libgio-2.0.so',
+              '../lib/libgmodule-2.0.so',
+              '../lib/libgsf-1.so',
+              '../lib/libgthread-2.0.so',
+              '../lib/libharfbuzz.so',
+              '../lib/libjpeg.so',
+              '../lib/liblcms2.so',
+              '../lib/liborc-0.4.so',
+              '../lib/libpango-1.0.so',
+              '../lib/libpangocairo-1.0.so',
+              '../lib/libpangoft2-1.0.so',
+              '../lib/libpixman-1.so',
+              '../lib/libpng.so',
+              '../lib/librsvg-2.so',
+              '../lib/libtiff.so',
+              '../lib/libwebp.so',
+              '../lib/libxml2.so',
+              '../lib/libz.so',
               # Ensure runtime linking is relative to sharp.node
-              '-Wl,-rpath=\'$${ORIGIN}/../../lib\''
+              '-Wl,--disable-new-dtags -Wl,-rpath=\'$${ORIGIN}/../../lib\''
             ]
           }]
         ]
@@ -167,6 +197,7 @@
       'CLANG_CXX_LIBRARY': 'libc++',
       'MACOSX_DEPLOYMENT_TARGET': '10.7',
       'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+      'GCC_ENABLE_CPP_RTTI': 'YES',
       'OTHER_CPLUSPLUSFLAGS': [
         '-fexceptions',
         '-Wall',
@@ -195,46 +226,48 @@
       ['OS == "win"', {
         # Windows lacks support for rpath
         'copies': [{
-          'destination': '<(module_root_dir)/build/Release',
+          'destination': 'build/Release',
           'files': [
-            '<(module_root_dir)/lib/GNU.Gettext.dll',
-            '<(module_root_dir)/lib/libMagickCore-6.Q16-2.dll',
-            '<(module_root_dir)/lib/libMagickWand-6.Q16-2.dll',
-            '<(module_root_dir)/lib/libasprintf-0.dll',
-            '<(module_root_dir)/lib/libcairo-2.dll',
-            '<(module_root_dir)/lib/libcairo-gobject-2.dll',
-            '<(module_root_dir)/lib/libcairo-script-interpreter-2.dll',
-            '<(module_root_dir)/lib/libexif-12.dll',
-            '<(module_root_dir)/lib/libexpat-1.dll',
-            '<(module_root_dir)/lib/libffi-6.dll',
-            '<(module_root_dir)/lib/libfftw3-3.dll',
-            '<(module_root_dir)/lib/libfontconfig-1.dll',
-            '<(module_root_dir)/lib/libfreetype-6.dll',
-            '<(module_root_dir)/lib/libgcc_s_seh-1.dll',
-            '<(module_root_dir)/lib/libgdk_pixbuf-2.0-0.dll',
-            '<(module_root_dir)/lib/libgio-2.0-0.dll',
-            '<(module_root_dir)/lib/libglib-2.0-0.dll',
-            '<(module_root_dir)/lib/libgmodule-2.0-0.dll',
-            '<(module_root_dir)/lib/libgobject-2.0-0.dll',
-            '<(module_root_dir)/lib/libgsf-1-114.dll',
-            '<(module_root_dir)/lib/libgthread-2.0-0.dll',
-            '<(module_root_dir)/lib/libintl-8.dll',
-            '<(module_root_dir)/lib/libjpeg-62.dll',
-            '<(module_root_dir)/lib/liblcms2-2.dll',
-            '<(module_root_dir)/lib/libopenjp2.dll',
-            '<(module_root_dir)/lib/libopenslide-0.dll',
-            '<(module_root_dir)/lib/libpango-1.0-0.dll',
-            '<(module_root_dir)/lib/libpangocairo-1.0-0.dll',
-            '<(module_root_dir)/lib/libpangowin32-1.0-0.dll',
-            '<(module_root_dir)/lib/libpixman-1-0.dll',
-            '<(module_root_dir)/lib/libpng16-16.dll',
-            '<(module_root_dir)/lib/libquadmath-0.dll',
-            '<(module_root_dir)/lib/libsqlite3-0.dll',
-            '<(module_root_dir)/lib/libssp-0.dll',
-            '<(module_root_dir)/lib/libtiff-5.dll',
-            '<(module_root_dir)/lib/libvips-42.dll',
-            '<(module_root_dir)/lib/libxml2-2.dll',
-            '<(module_root_dir)/lib/zlib1.dll'
+            'lib/GNU.Gettext.dll',
+            'lib/libasprintf-0.dll',
+            'lib/libcairo-2.dll',
+            'lib/libcairo-gobject-2.dll',
+            'lib/libcairo-script-interpreter-2.dll',
+            'lib/libcharset-1.dll',
+            'lib/libcroco-0.6-3.dll',
+            'lib/libexif-12.dll',
+            'lib/libexpat-1.dll',
+            'lib/libffi-6.dll',
+            'lib/libfftw3-3.dll',
+            'lib/libfontconfig-1.dll',
+            'lib/libfreetype-6.dll',
+            'lib/libgcc_s_seh-1.dll',
+            'lib/libgdk_pixbuf-2.0-0.dll',
+            'lib/libgif-7.dll',
+            'lib/libgio-2.0-0.dll',
+            'lib/libglib-2.0-0.dll',
+            'lib/libgmodule-2.0-0.dll',
+            'lib/libgobject-2.0-0.dll',
+            'lib/libgsf-1-114.dll',
+            'lib/libgthread-2.0-0.dll',
+            'lib/libiconv-2.dll',
+            'lib/libintl-8.dll',
+            'lib/libjpeg-62.dll',
+            'lib/liblcms2-2.dll',
+            'lib/libpango-1.0-0.dll',
+            'lib/libpangocairo-1.0-0.dll',
+            'lib/libpangowin32-1.0-0.dll',
+            'lib/libpixman-1-0.dll',
+            'lib/libpng16-16.dll',
+            'lib/libquadmath-0.dll',
+            'lib/librsvg-2-2.dll',
+            'lib/libssp-0.dll',
+            'lib/libstdc++-6.dll',
+            'lib/libtiff-5.dll',
+            'lib/libvips-42.dll',
+            'lib/libwebp-6.dll',
+            'lib/libxml2-2.dll',
+            'lib/zlib1.dll'
           ]
         }]
       }]

binding.js

@@ -12,8 +12,21 @@ var tmp = require('os').tmpdir();
 
 var distBaseUrl = 'https://dl.bintray.com/lovell/sharp/';
 
+// Use NPM-provided environment variable where available, falling back to require-based method for Electron
+var minimumLibvipsVersion = process.env.npm_package_config_libvips || require('./package.json').config.libvips;
+
 var vipsHeaderPath = path.join(__dirname, 'include', 'vips', 'vips.h');
 
+var platform = process.env.npm_config_platform || process.platform;
+
+var arch = process.env.npm_config_arch || process.arch;
+var arm_version = process.env.npm_config_armv || process.config.variables.arm_version;
+
+if (arch === 'arch64' || arch === 'armhf') {
+  arch = 'arm';
+  if (arch === 'arch64') arm_version = '8';
+}
+
 // -- Helpers
 
 // Does this file exist?
@@ -43,6 +56,24 @@ var unpack = function(tarPath, done) {
     .pipe(extractor);
 };
 
+var platformId = function() {
+  var id = [platform, arch].join('-');
+  if (arch === 'arm') {
+    switch(arm_version) {
+      case '8':
+        id = id + 'v8';
+        break;
+      case '7':
+        id = id + 'v7';
+        break;
+      default:
+        id = id + 'v6';
+        break;
+    }
+  }
+  return id;
+};
+
 // Error
 var error = function(msg) {
   if (msg instanceof Error) {
@@ -58,7 +89,7 @@ module.exports.download_vips = function() {
   // Has vips been installed locally?
   if (!isFile(vipsHeaderPath)) {
     // Ensure Intel 64-bit or ARM
-    if (process.arch === 'ia32') {
+    if (arch === 'ia32') {
       error('Intel Architecture 32-bit systems require manual installation - please see http://sharp.dimens.io/en/stable/install/');
     }
     // Ensure glibc >= 2.15
@@ -74,8 +105,7 @@ module.exports.download_vips = function() {
       }
     }
     // Arch/platform-specific .tar.gz
-    var platform = (process.arch === 'arm') ? 'arm' : process.platform.substr(0, 3);
-    var tarFilename = ['libvips', process.env.npm_package_config_libvips, platform].join('-') + '.tar.gz';
+    var tarFilename = ['libvips', minimumLibvipsVersion, platformId()].join('-') + '.tar.gz';
     var tarPath = path.join(__dirname, 'packaging', tarFilename);
     if (isFile(tarPath)) {
       unpack(tarPath);
@@ -114,18 +144,8 @@ module.exports.use_global_vips = function() {
   if (globalVipsVersion) {
     useGlobalVips = semver.gte(
       globalVipsVersion,
-      process.env.npm_package_config_libvips
+      minimumLibvipsVersion
     );
   }
-  if (process.platform === 'darwin' && !useGlobalVips) {
-    if (globalVipsVersion) {
-      error(
-        'Found libvips ' + globalVipsVersion + ' but require ' + process.env.npm_package_config_libvips +
-        '\nPlease upgrade libvips by running: brew update && brew upgrade'
-      );
-    } else {
-      error('Please install libvips by running: brew install homebrew/science/vips --with-webp --with-graphicsmagick');
-    }
-  }
   process.stdout.write(useGlobalVips ? 'true' : 'false');
 };

circle.yml

@@ -3,4 +3,4 @@ machine:
     - docker
 test:
   override:
-    - ./packaging/test.sh
+    - ./packaging/test-linux-x64.sh

docs/api.md

@@ -13,7 +13,7 @@ Constructor to which further methods are chained.
 `input`, if present, can be one of:
 
 * Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
-* String containing the path to an image file, with most major formats supported.
+* String containing the path to an JPEG, PNG, WebP, GIF, SVG or TIFF image file.
 
 JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data
 can be streamed into the object when `input` is `null` or `undefined`.
@@ -57,10 +57,10 @@ 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`, `openslide`, `ppm`, `fits`)
+* `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
 * `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)
+* `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#L568)
 * `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
 * `density`: Number of pixels per inch (DPI), if present
 * `hasProfile`: Boolean indicating the presence of an embedded ICC profile
@@ -113,11 +113,12 @@ This will reduce memory usage and can improve performance on some systems.
 
 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).
+`pixels` is either an integral Number of pixels, with a value between 1 and the default 268402689 (0x3FFF * 0x3FFF) or
+ a boolean. `false` will disable checking while `true` will revert to the default limit.
 
 ### Resizing
 
-#### resize([width], [height])
+#### resize([width], [height], [options])
 
 Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
 
@@ -125,6 +126,42 @@ Scale output to `width` x `height`. By default, the resized image is cropped to
 
 `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.
 
+`options` is an optional Object. If present, it can contain one or more of:
+
+* `options.kernel`, the kernel to use for image reduction, defaulting to `lanczos3`.
+* `options.interpolator`, the interpolator to use for image enlargement, defaulting to `bicubic`.
+
+Possible kernels are:
+
+* `cubic`: Use a [Catmull-Rom spline](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline).
+* `lanczos2`: Use a [Lanczos kernel](https://en.wikipedia.org/wiki/Lanczos_resampling#Lanczos_kernel) with `a=2`.
+* `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
+
+Possible interpolators are:
+
+* `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation).
+* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), faster than bicubic but with less smooth results.
+* `vertexSplitQuadraticBasisSpline`: Use the smoother [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48) to prevent "staircasing" when enlarging.
+* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default).
+* `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)" but typically reduces performance by a factor of 2.
+* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance but typically reduces performance by a factor of 3.
+
+```javascript
+sharp(inputBuffer)
+  .resize(200, 300, {
+    kernel: sharp.kernel.lanczos2,
+    interpolator: 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 lanczos2/nohalo scaled version, embedded on a white canvas,
+    // of the image data in inputBuffer
+  });
+```
+
 #### crop([option])
 
 Crop the resized image to the exact size specified, the default behaviour.
@@ -138,12 +175,11 @@ Possible attributes of `sharp.gravity` are
 `north`, `northeast`, `east`, `southeast`, `south`,
 `southwest`, `west`, `northwest`, `center` and `centre`.
 
-Possible attributes of the experimental `sharp.strategy` are:
+The experimental strategy-based approach resizes so one dimension is at its target length
+then repeatedly ranks edge regions, discarding the edge with the lowest score based on the selected strategy.
 
-* `entropy`: resize so one dimension is at its target size
-then repeatedly remove pixels from the edge with the lowest
-[Shannon entropy](https://en.wikipedia.org/wiki/Entropy_%28information_theory%29)
-until it too reaches the target size.
+* `entropy`: focus on the region with the highest [Shannon entropy](https://en.wikipedia.org/wiki/Entropy_%28information_theory%29).
+* `attention`: focus on the region with the highest luminance frequency, colour saturation and presence of skin tones.
 
 The default crop option is a `center`/`centre` gravity.
 
@@ -231,37 +267,6 @@ if its width or height exceeds the geometry specification*".
 
 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`.
-
-The default interpolator is `bicubic`, providing a general-purpose interpolator that is both fast and of good quality.
-
-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), faster than bicubic but with less smooth results.
-* `vertexSplitQuadraticBasisSpline`: Use the smoother [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48) to prevent "staircasing" when enlarging.
-* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default).
-* `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)" but typically reduces performance by a factor of 2.
-* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance but typically reduces performance by a factor of 3.
-
-[Compare the output of these interpolators](https://github.com/lovell/sharp/tree/master/test/interpolators)
-
-```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({ left: left, top: top, width: width, height: height })
@@ -292,6 +297,12 @@ sharp(input)
   });
 ```
 
+#### trim([tolerance])
+
+Trim "boring" pixels from all edges that contain values within a percentage similarity of the top-left pixel.
+
+* `tolerance`, if present, is an integral Number between 1 and 99 representing the percentage similarity, defaulting to 10.
+
 #### background(rgba)
 
 Set the background for the `embed`, `flatten` and `extend` operations.
@@ -373,23 +384,49 @@ When used without parameters, performs a fast, mild blur of the output image. Th
 
 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.
+* `sigma`, if present, is a Number between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
 
-#### sharpen([radius], [flat], [jagged])
+#### convolve(kernel)
+
+Convolve the image with the specified `kernel`, an Object with the following attributes:
+
+* `width` is an integral Number representing the width of the kernel in pixels.
+* `height` is an integral Number representing the width of the kernel in pixels.
+* `kernel` is an Array of length `width*height` containing the kernel values.
+* `scale`, if present, is a Number representing the scale of the kernel in pixels, defaulting to the sum of the kernel's values.
+* `offset`, if present, is a Number representing the offset of the kernel in pixels, defaulting to 0.
+
+```javascript
+sharp(input)
+  .convolve({
+    width: 3,
+    height: 3,
+    kernel: [-1, 0, 1, -2, 0, 2, -1, 0, 1]
+  })
+  .raw()
+  .toBuffer(function(err, data, info) {
+    // data contains the raw pixel data representing the convolution
+    // of the input image with the horizontal Sobel operator
+  });
+```
+
+#### sharpen([sigma], [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%.
+When a `sigma` 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.
+* `sigma`, if present, is a Number representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
 * `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.
 
-#### threshold([threshold])
+#### threshold([threshold], [options])
 
-Converts all pixels in the image to greyscale white or black.  Any pixel greather-than-or-equal-to the threshold (0..255) will be white.  All others will be black.
+Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+By default, the image will be converted to single channel greyscale before thresholding.
 
-* `threshold`, if present, is a Number, representing the level above which pixels will be forced to white.
+* `threshold`, if present, is a Number between 0 and 255, representing the level at which the threshold will be applied. The default threshold is 128.
+* `options`, if present, is an Object containing a Boolean `greyscale` (or `grayscale`). When `false` each channel will have the threshold applied independently.
 
 #### gamma([gamma])
 
@@ -407,7 +444,7 @@ 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.
+By default the output image will be web-friendly sRGB and contain three (identical) color channels. This may be overridden by other sharp operations such as `toColourspace('b-w')`, which will produce an output image containing one color channel. An alpha channel may be present, and will be unchanged by the operation.
 
 #### normalize() / normalise()
 
@@ -415,16 +452,23 @@ Enhance output image contrast by stretching its luminance to cover the full dyna
 
 #### overlayWith(image, [options])
 
-Overlay (composite) a image containing an alpha channel over the processed (resized, extracted etc.) image.
+Overlay (composite) a image over the processed (resized, extracted etc.) image.
 
 `image` is one of the following, and must be the same size or smaller than the processed image:
 
-* Buffer containing PNG, WebP, GIF or SVG image data, or
-* String containing the path to an image file, with most major transparency formats supported.
+* Buffer containing image data, or
+* String containing the path to an image file
 
 `options`, if present, is an Object with the following optional attributes:
 
 * `gravity` is a String or an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north` at which to place the overlay, defaulting to `center`/`centre`.
+* `top` is an integral Number representing the pixel offset from the top edge.
+* `left` is an integral Number representing the pixel offset from the left edge.
+* `tile` is a Boolean, defaulting to `false`. When set to `true` repeats the overlay image across the entire image with the given `gravity`.
+* `cutout` is a Boolean, defaulting to `false`. When set to `true` applies only the alpha channel of the overlay image to the image to be overlaid, giving the appearance of one image being cut out of another.
+* `raw` an Object containing `width`, `height` and `channels` when providing uncompressed data.
+
+If both `top` and `left` are provided, they take precedence over `gravity`.
 
 ```javascript
 sharp('input.png')
@@ -445,13 +489,87 @@ sharp('input.png')
   });
 ```
 
+#### toColourspace(colourspace) / toColorspace(colorspace)
+
+Set the output colourspace. By default output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.  
+  
+`colourspace` is a string or `sharp.colourspace` enum that identifies an output colourspace. String arguments comprise vips colour space interpretation names  e.g. `srgb`, `rgb`, `scrgb`, `cmyk`, `lab`, `xyz`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L568)
+  
+#### extractChannel(channel)
+
+Extract a single channel from a multi-channel image.
+
+`channel` is a zero-indexed integral Number representing the band number to extract. `red`, `green` or `blue` are also accepted as an alternative to `0`, `1` or `2` respectively.
+
+```javascript
+sharp(input)
+  .extractChannel('green')
+  .toFile('input_green.jpg', function(err, info) {
+    // info.channels === 1
+    // input_green.jpg contains the green channel of the input image
+   });
+```
+
+#### joinChannel(channels, [options])
+
+Join a data channel to the image. The meaning of the added channels depends on the output colourspace, set with `toColourspace()`. By default the output image will be web-friendly sRGB, with additional channels interpreted as alpha channels.
+
+`channels` is one of
+* a single file path
+* an array of file paths
+* a single buffer
+* an array of buffers
+
+Note that channel ordering follows vips convention:
+* sRGB: 0: Red, 1: Green, 2: Blue, 3: Alpha
+* CMYK: 0: Magenta, 1: Cyan, 2: Yellow, 3: Black, 4: Alpha
+
+Buffers may be any of the image formats supported by sharp: JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data. In the case of a RAW buffer, the `options` object should contain a `raw` attribute, which follows the format of the attribute of the same name in the `sharp()` constructor. See `sharp()` for details. See `raw()` for pixel ordering. 
+
+#### bandbool(operation)
+
+Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+
+`operation` is a string containing the name of the bitwise operator to be appled to image channels, which can be one of:
+
+* `and` performs a bitwise and operation, like the c-operator `&`.
+* `or` performs a bitwise or operation, like the c-operator `|`.
+* `eor` performs a bitwise exclusive or operation, like the c-operator `^`.
+
+```javascript
+sharp('input.png')
+  .bandbool(sharp.bool.and)
+  .toFile('output.png')
+```
+
+In the above example if `input.png` is a 3 channel RGB image, `output.png` will be a 1 channel grayscale image where each pixel `P = R & G & B`.
+For example, if `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]` then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+
+#### boolean(image, operation, [options])
+
+Perform a bitwise boolean operation with `image`, where `image` is one of the following:
+
+* Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
+* String containing the path to an image file
+
+This operation creates an output image where each pixel is the result of the selected bitwise boolean `operation` between the corresponding pixels of the input images.
+The boolean operation can be one of the following:
+
+* `and` performs a bitwise and operation, like the c-operator `&`.
+* `or` performs a bitwise or operation, like the c-operator `|`.
+* `eor` performs a bitwise exclusive or operation, like the c-operator `^`.
+
+`options`, if present, is an Object with the following optional attributes:
+
+* `raw` an Object containing `width`, `height` and `channels` when providing uncompressed data.
+
 ### Output
 
 #### toFile(path, [callback])
 
 `path` is a String containing the path to write the image data to.
 
-If an explicit output format is not selected, it will be inferred from the extension, with JPEG, PNG, WebP, TIFF and DZI supported.
+If an explicit output format is not selected, it will be inferred from the extension, with JPEG, PNG, WebP, TIFF, DZI, and VIPS V format supported. Note that RAW format is only supported for buffer output.
 
 `callback`, if present, is called with two arguments `(err, info)` where:
 
@@ -462,7 +580,7 @@ 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.
+Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG, WebP, and RAW are supported.
 
 `callback`, if present, gets three arguments `(err, buffer, info)` where:
 
@@ -526,14 +644,17 @@ The default behaviour, when `withMetadata` is not used, is to strip all metadata
 
 #### tile(options)
 
-The size, overlap and directory layout to use when generating square Deep Zoom image pyramid tiles.
+The size, overlap, container and directory layout to use when generating square Deep Zoom image pyramid tiles.
 
 `options` is an Object with one or more of the following attributes:
 
 * `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.
+* `container` is a String, with value `fs` or `zip`. The default value is `fs`.
 * `layout` is a String, with value `dz`, `zoomify` or `google`. The default value is `dz`.
 
+You can also use the file extension `.zip` or `.szi` to write to a compressed archive file format.
+
 ```javascript
 sharp('input.tiff')
   .tile({
@@ -611,9 +732,6 @@ for example:
   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 } } }
@@ -637,22 +755,7 @@ sharp.queue.on('change', function(queueLength) {
 An Object containing the version numbers of libvips and, on Linux, its dependencies.
 
 ```javascript
-> console.log(sharp.versions);
-
-{ zlib: '1.2.8',
-  ffi: '3.2.1',
-  glib: '2.46.2',
-  xml: '2.9.2',
-  gsf: '1.14.34',
-  exif: '0.6.21',
-  jpeg: '1.4.2',
-  png: '1.6.19',
-  lcms: '2.7',
-  webp: '0.4.4',
-  tiff: '4.0.6',
-  magick: '6.9.2-6',
-  orc: '0.4.24',
-  vips: '8.1.1' }
+console.log(sharp.versions);
 ```
 
 ### Utilities
@@ -667,6 +770,8 @@ If `options` is provided, sets the limits of _libvips'_ operation cache.
 
 `options` can also be a boolean, where `true` enables the default cache settings and `false` disables all caching.
 
+Existing entries in the cache will be trimmed after any change in limits.
+
 This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
 
 ```javascript

docs/changelog.md

@@ -1,9 +1,184 @@
 # Changelog
 
+### v0.16 - "*pencil*"
+
+Requires libvips v8.3.3
+
+#### v0.16.1 - 13<sup>th</sup> October 2016
+
+* C++11 ABI version is now auto-detected, remove sharp-cxx11 installation flag.
+
+* Add experimental 'attention' crop strategy.
+  [#295](https://github.com/lovell/sharp/issues/295)
+
+* Include .node extension for Meteor's require() implementation.
+  [#537](https://github.com/lovell/sharp/issues/537)
+  [@isjackwild](https://github.com/isjackwild)
+
+* Ensure convolution kernel scale is clamped to a minimum value of 1.
+  [#561](https://github.com/lovell/sharp/issues/561)
+  [@abagshaw](https://github.com/abagshaw)
+
+* Correct calculation of y-axis placement when overlaying image at a fixed point.
+  [#566](https://github.com/lovell/sharp/issues/566)
+  [@Nateowami](https://github.com/Nateowami)
+
+#### v0.16.0 - 18<sup>th</sup> August 2016
+
+* Add pre-compiled libvips for OS X, ARMv7 and ARMv8.
+  [#312](https://github.com/lovell/sharp/issues/312)
+
+* Ensure boolean, bandbool, extractChannel ops occur before sRGB conversion.
+  [#504](https://github.com/lovell/sharp/pull/504)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Recalculate factors after WebP shrink-on-load to avoid round-to-zero errors.
+  [#508](https://github.com/lovell/sharp/issues/508)
+  [@asilvas](https://github.com/asilvas)
+
+* Prevent boolean errors during extract operation.
+  [#511](https://github.com/lovell/sharp/pull/511)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add joinChannel and toColourspace/toColorspace operations.
+  [#513](https://github.com/lovell/sharp/pull/513)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add support for raw pixel data with boolean and withOverlay operations.
+  [#516](https://github.com/lovell/sharp/pull/516)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Prevent bandbool creating a single channel sRGB image.
+  [#519](https://github.com/lovell/sharp/pull/519)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Ensure ICC profiles are removed from PNG output unless withMetadata used.
+  [#521](https://github.com/lovell/sharp/issues/521)
+  [@ChrisPinewood](https://github.com/ChrisPinewood)
+
+* Add alpha channels, if missing, to overlayWith images.
+  [#540](https://github.com/lovell/sharp/pull/540)
+  [@cmtt](https://github.com/cmtt)
+
+* Remove deprecated interpolateWith method - use resize(w, h, { interpolator: ... })
+  [#310](https://github.com/lovell/sharp/issues/310)
+
+### v0.15 - "*outfit*"
+
+Requires libvips v8.3.1
+
+#### v0.15.1 - 12<sup>th</sup> July 2016
+
+* Concat Stream-based input in single operation for ~+3% perf and less GC.
+  [#429](https://github.com/lovell/sharp/issues/429)
+  [@papandreou](https://github.com/papandreou)
+
+* Add alpha channel, if required, before extend operation.
+  [#439](https://github.com/lovell/sharp/pull/439)
+  [@frulo](https://github.com/frulo)
+
+* Allow overlay image to be repeated across entire image via tile option.
+  [#443](https://github.com/lovell/sharp/pull/443)
+  [@lemnisk8](https://github.com/lemnisk8)
+
+* Add cutout option to overlayWith feature, applies only the alpha channel of the overlay image.
+  [#448](https://github.com/lovell/sharp/pull/448)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Ensure scaling factors are calculated independently to prevent rounding errors.
+  [#452](https://github.com/lovell/sharp/issues/452)
+  [@puzrin](https://github.com/puzrin)
+
+* Add --sharp-cxx11 flag to compile with gcc's new C++11 ABI.
+  [#456](https://github.com/lovell/sharp/pull/456)
+  [@kapouer](https://github.com/kapouer)
+
+* Add top/left offset support to overlayWith operation.
+  [#473](https://github.com/lovell/sharp/pull/473)
+  [@rnanwani](https://github.com/rnanwani)
+
+* Add convolve operation for kernel-based convolution.
+  [#479](https://github.com/lovell/sharp/pull/479)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add greyscale option to threshold operation for colourspace conversion control.
+  [#480](https://github.com/lovell/sharp/pull/480)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Ensure ICC profiles are licenced for distribution.
+  [#486](https://github.com/lovell/sharp/issues/486)
+  [@kapouer](https://github.com/kapouer)
+
+* Allow images with an alpha channel to work with LAB-colourspace based sharpen.
+  [#490](https://github.com/lovell/sharp/issues/490)
+  [@jwagner](https://github.com/jwagner)
+
+* Add trim operation to remove "boring" edges.
+  [#492](https://github.com/lovell/sharp/pull/492)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Add bandbool feature for channel-wise boolean operations.
+  [#496](https://github.com/lovell/sharp/pull/496)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add extractChannel operation to extract a channel from an image.
+  [#497](https://github.com/lovell/sharp/pull/497)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add ability to read and write native libvips .v files.
+  [#500](https://github.com/lovell/sharp/pull/500)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add boolean feature for bitwise image operations.
+  [#501](https://github.com/lovell/sharp/pull/501)
+  [@mhirsch](https://github.com/mhirsch)
+
+#### v0.15.0 - 21<sup>st</sup> May 2016
+
+* Use libvips' new Lanczos 3 kernel as default for image reduction.
+  Deprecate interpolateWith method, now provided as a resize option.
+  [#310](https://github.com/lovell/sharp/issues/310)
+  [@jcupitt](https://github.com/jcupitt)
+
+* Take advantage of libvips v8.3 features.
+  Add support for libvips' new GIF and SVG loaders.
+  Pre-built binaries now include giflib and librsvg, exclude *magick.
+  Use shrink-on-load for WebP input.
+  Break existing sharpen API to accept sigma and improve precision.
+  [#369](https://github.com/lovell/sharp/issues/369)
+
+* Remove unnecessary (un)premultiply operations when not resizing/compositing.
+  [#413](https://github.com/lovell/sharp/issues/413)
+  [@jardakotesovec](https://github.com/jardakotesovec)
+
 ### v0.14 - "*needle*"
 
 Requires libvips v8.2.3
 
+#### v0.14.1 - 16<sup>th</sup> April 2016
+
+* Allow removal of limitation on input pixel count via limitInputPixels. Use with care.
+  [#250](https://github.com/lovell/sharp/issues/250)
+  [#316](https://github.com/lovell/sharp/pull/316)
+  [@anandthakker](https://github.com/anandthakker)
+  [@kentongray](https://github.com/kentongray)
+
+* Use final output image for metadata passed to callback.
+  [#399](https://github.com/lovell/sharp/pull/399)
+  [@salzhrani](https://github.com/salzhrani)
+
+* Add support for writing tiled images to a zip container.
+  [#402](https://github.com/lovell/sharp/pull/402)
+  [@felixbuenemann](https://github.com/felixbuenemann)
+
+* Allow use of embed with 1 and 2 channel images.
+  [#411](https://github.com/lovell/sharp/issues/411)
+  [@janaz](https://github.com/janaz)
+
+* Improve Electron compatibility by allowing node-gyp rebuilds without npm.
+  [#412](https://github.com/lovell/sharp/issues/412)
+  [@nouh](https://github.com/nouh)
+
 #### v0.14.0 - 2<sup>nd</sup> April 2016
 
 * Add ability to extend (pad) the edges of an image.
@@ -38,6 +213,9 @@ Requires libvips v8.2.3
   [#387](https://github.com/lovell/sharp/issues/387)
   [@kleisauke](https://github.com/kleisauke)
 
+* Remove deprecated style of calling extract API. Breaks calls using positional arguments.
+  [#276](https://github.com/lovell/sharp/issues/276)
+
 ### v0.13 - "*mind*"
 
 Requires libvips v8.2.2

docs/index.md

@@ -1,30 +1,26 @@
 # sharp
 
 The typical use case for this high speed Node.js module
-is to convert large images of many formats to
+is to convert large images in common formats to
 smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
 
-Resizing an image is typically 4x faster than using the
+Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings.
 
 Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
-Bicubic interpolation with Lanczos anti-alias filtering ensures quality is not sacrificed for speed.
+Lanczos resampling ensures quality is not sacrificed for speed.
 
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
 
-Most Windows (x64), Linux and ARMv6+ systems do not require
+OS X, Windows (x64), Linux (x64, ARM) systems do not require
 the installation of any external runtime dependencies.
 
-Use with OS X is as simple as running `brew install homebrew/science/vips`
-to install the libvips dependency.
-
 [![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 most other libmagick-supported formats.
+This module supports reading JPEG, PNG, WebP, TIFF, GIF and SVG images.
 
 Output images can be in JPEG, PNG and WebP formats as well as uncompressed raw pixel data.
 
@@ -89,12 +85,21 @@ the help and code contributions of the following people:
 * [Alaric Holloway](https://github.com/skedastik)
 * [Bernhard K. Weisshuhn](https://github.com/bkw)
 * [David A. Carley](https://github.com/dacarley)
+* [John Tobin](https://github.com/jtobinisaniceguy)
+* [Kenton Gray](https://github.com/kentongray)
+* [Felix Bünemann](https://github.com/felixbuenemann)
+* [Samy Al Zahrani](https://github.com/salzhrani)
+* [Chintan Thakkar](https://github.com/lemnisk8)
+* [F. Orlando Galashan](https://github.com/frulo)
+* [Kleis Auke Wolthuizen](https://github.com/kleisauke)
+* [Matt Hirsch](https://github.com/mhirsch)
+* [Rahul Nanwani](https://github.com/rnanwani)
 
 Thank you!
 
 ### Licence
 
-Copyright 2013, 2014, 2015 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016 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.

docs/install.md

@@ -6,8 +6,8 @@ npm install sharp
 
 ### Prerequisites
 
-* C++11 compatible compiler such as gcc 4.6+ (Node v4+ requires gcc 4.8+), clang 3.0+ or MSVC 2013
-* [node-gyp](https://github.com/TooTallNate/node-gyp#installation)
+* C++11 compatible compiler such as gcc 4.8+, clang 3.0+ or MSVC 2013+
+* [node-gyp](https://github.com/TooTallNate/node-gyp#installation) and its dependencies
 
 ### Linux
 
@@ -15,36 +15,37 @@ npm install sharp
 [![Linux Build Status](https://circleci.com/gh/lovell/sharp.svg?style=svg&circle-token=6cb6d1d287a51af83722b19ed8885377fbc85e5c)](https://circleci.com/gh/lovell/sharp)
 
 libvips and its dependencies are fetched and stored within `node_modules/sharp/lib` during `npm install`.
-This involves an automated HTTPS download of approximately 6MB.
+This involves an automated HTTPS download of approximately 6.5MB.
 
 Most recent Linux-based operating systems with glibc running on x64 and ARMv6+ CPUs should "just work", e.g.:
 
 * Debian 7, 8
-* Ubuntu 12.04, 14.04, 14.10, 15.04, 15.10
+* Ubuntu 12.04, 14.04, 16.04
 * Centos 7
-* Fedora 21, 22, 23
+* Fedora 23, 24
 * openSUSE 13.2
-* Archlinux 2015.06.01
+* Archlinux
 * Raspbian Jessie
-* Amazon Linux 2015.03, 2015.09
+* Amazon Linux 2016.03, 2016.09
 
-To use your own version of libvips instead of the provided binaries, make sure it is
-at least the version listed under `config.libvips` in the `package.json` file that it
-can be located using `pkg-config`. If you are using non-stadard paths (anything other
-than `/usr` or `/usr/local`), you might need to set `PKG_CONFIG_PATH` during `npm install`
+To use a globally-installed version of libvips instead of the provided binaries,
+make sure it is at least the version listed under `config.libvips` in the `package.json` file
+and that it can be located using `pkg-config --modversion vips-cpp`.
+
+If you are using non-stadard paths (anything other than `/usr` or `/usr/local`),
+you might need to set `PKG_CONFIG_PATH` during `npm install`
 and `LD_LIBRARY_PATH` at runtime.
 
-You can print the detected vips version using: `pkg-config --modversion vips-cpp`
-
 This allows the use of newer versions of libvips with older versions of sharp.
 
-For older Linux-based operating systems and 32-bit Intel CPUs,
+For 32-bit Intel CPUs and older Linux-based operating systems such as Centos 6,
 a system-wide installation of the most suitable version of
 libvips and its dependencies can be achieved by running
 the following command as a user with `sudo` access
 (requires `curl` and `pkg-config`):
 
 ```sh
+# WARNING: This script is deprecated. You probably don't need to run it. Please read above.
 curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
 ```
 
@@ -54,32 +55,16 @@ via `sharp.cache(false)` to avoid a stack overflow.
 
 ### 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)
+[![OS X 10.9.5 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
 
-libvips must be installed before `npm install` is run.
-This can be achieved via homebrew:
+libvips and its dependencies are fetched and stored within `node_modules/sharp/lib` during `npm install`.
+This involves an automated HTTPS download of approximately 6.5MB.
 
-```sh
-brew install homebrew/science/vips
-```
+To use your own version of libvips instead of the provided binaries, make sure it is
+at least the version listed under `config.libvips` in the `package.json` file and
+that it can be located using `pkg-config --modversion vips-cpp`.
 
-For GIF input and WebP output suppport use:
-
-```sh
-brew install homebrew/science/vips --with-imagemagick --with-webp
-```
-
-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 x64
 
 [![Windows x64 Build Status](https://ci.appveyor.com/api/projects/status/pgtul704nkhhg6sg)](https://ci.appveyor.com/project/lovell/sharp)
 
@@ -87,7 +72,6 @@ libvips and its dependencies are fetched and stored within `node_modules\sharp`
 This involves an automated HTTPS download of approximately 9MB.
 
 Only 64-bit (x64) `node.exe` is supported.
-The WebP format is currently unavailable on Windows.
 
 ### FreeBSD
 
@@ -128,12 +112,11 @@ do this on a system similar to the [Lambda Execution Environment](http://docs.aw
 small t2.micro instance using the AMI ID listed in the previous link, ssh into it as ec2-user
 and follow the instructions below.
 
-Install depencies:
+Install dependencies:
 
 ```sh
-sudo yum-config-manager --enable epel
-sudo yum install -y nodejs gcc-c++
-curl -s https://www.npmjs.com/install.sh | sudo sh
+curl -s https://rpm.nodesource.com/setup_4.x | sudo bash -
+sudo yum install -y gcc-c++ nodejs
 ```
 
 Copy your code and package.json to the instance using `scp` and create a deployment package:
@@ -144,7 +127,7 @@ npm install
 zip -ur9 ../sharp-lambda-example.zip index.js node_modules
 ```
 
-You can now download your deployment ZIP using `scp` and upload it to Lambda.
+You can now download your deployment ZIP using `scp` and upload it to Lambda. Be sure to set your Lambda runtime to Node.js 4.3.
 
 **Performance Tip:** To get the best performance on Lambda choose the largest memory available because this also gives you the most cpu time (a 1536 MB function is 12x faster than a 128 MB function).
 
@@ -152,3 +135,82 @@ You can now download your deployment ZIP using `scp` and upload it to Lambda.
 
 * [gulp-responsive](https://www.npmjs.com/package/gulp-responsive)
 * [grunt-sharp](https://www.npmjs.com/package/grunt-sharp)
+
+### Security
+
+Many users of this module process untrusted, user-supplied images,
+but there are aspects of security to consider when doing so.
+
+It is possible to compile libvips with support for various third-party image loaders.
+Each of these libraries has undergone differing levels of security testing.
+
+Whilst tools such as [American Fuzzy Lop](http://lcamtuf.coredump.cx/afl/)
+and [Valgrind](http://valgrind.org/) have been used to test
+the most popular web-based formats, as well as libvips itself,
+you are advised to perform your own testing and sandboxing.
+
+ImageMagick in particular has a relatively large attack surface,
+which can be partially mitigated with a
+[policy.xml](http://www.imagemagick.org/script/resources.php)
+configuration file to prevent the use of coders known to be vulnerable.
+
+```xml
+<policymap>
+  <policy domain="coder" rights="none" pattern="EPHEMERAL" />
+  <policy domain="coder" rights="none" pattern="URL" />
+  <policy domain="coder" rights="none" pattern="HTTPS" />
+  <policy domain="coder" rights="none" pattern="MVG" />
+  <policy domain="coder" rights="none" pattern="MSL" />
+  <policy domain="coder" rights="none" pattern="TEXT" />
+  <policy domain="coder" rights="none" pattern="SHOW" />
+  <policy domain="coder" rights="none" pattern="WIN" />
+  <policy domain="coder" rights="none" pattern="PLT" />
+</policymap>
+```
+
+Set the `MAGICK_CONFIGURE_PATH` environment variable
+to the directory containing the `policy.xml` file.
+
+### Licences
+
+If a global installation of libvips that meets the
+minimum version requirement cannot be found,
+this module will download a pre-compiled bundle of libvips
+and its dependencies on Linux and Windows machines.
+
+Should you need to manually download and inspect these files,
+you can do so via https://dl.bintray.com/lovell/sharp/
+
+This module is licensed under the terms of the
+[Apache 2.0 Licence](https://github.com/lovell/sharp/blob/master/LICENSE).
+
+The libraries downloaded and used by this module
+are done so under the terms of the following licences,
+all of which are compatible with the Apache 2.0 Licence.
+
+Use of libraries under the terms of the LGPLv3 is via the
+"any later version" clause of the LGPLv2 or LGPLv2.1.
+
+| Library       | Used under the terms of                                                                                  |
+|---------------|----------------------------------------------------------------------------------------------------------|
+| cairo         | Mozilla Public License 2.0                                                                               |
+| fontconfig    | [fontconfig Licence](https://cgit.freedesktop.org/fontconfig/tree/COPYING) (BSD-like)                    |
+| freetype      | [freetype Licence](http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
+| giflib        | MIT Licence                                                                                              |
+| glib          | LGPLv3                                                                                                   |
+| harfbuzz      | MIT Licence                                                                                              |
+| lcms          | MIT Licence                                                                                              |
+| libcroco      | LGPLv3                                                                                                   |
+| libexif       | LGPLv3                                                                                                   |
+| libffi        | MIT Licence                                                                                              |
+| libgsf        | LGPLv3                                                                                                   |
+| libjpeg-turbo | [zlib License, IJG License](https://github.com/libjpeg-turbo/libjpeg-turbo/blob/master/LICENSE.md)       |
+| libpng        | [libpng License](http://www.libpng.org/pub/png/src/libpng-LICENSE.txt)                                   |
+| librsvg       | LGPLv3                                                                                                   |
+| libtiff       | [libtiff License](http://www.libtiff.org/misc.html) (BSD-like)                                           |
+| libvips       | LGPLv3                                                                                                   |
+| libwebp       | New BSD License                                                                                          |
+| libxml2       | MIT Licence                                                                                              |
+| pango         | LGPLv3                                                                                                   |
+| pixman        | MIT Licence                                                                                              |
+| zlib          | [zlib Licence](https://github.com/madler/zlib/blob/master/zlib.h)                                        |

docs/performance.md

@@ -2,42 +2,45 @@
 
 ### Test environment
 
-* AWS EC2 [c4.xlarge](http://aws.amazon.com/ec2/instance-types/#c4) (4x E5-2666 v3 @2.90GHz)
-* Amazon Linux 2015.09.1
-* Node.js v5.5.0
+* AWS EC2 [c4.xlarge](http://aws.amazon.com/ec2/instance-types/#c4) (4x E5-2666 v3 @ 2.90GHz)
+* Amazon Linux AMI 2016.03.1 (HVM), SSD Volume Type
+* Node.js v6.2.0
 
 ### The contenders
 
-* [jimp](https://www.npmjs.com/package/jimp) v0.2.20 - Image processing in pure JavaScript. Bilinear interpolation only.
-* [lwip](https://www.npmjs.com/package/lwip) v0.0.8 - Wrapper around CImg, compiles dependencies from source.
-* [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) @47c7329 - Wrapper around libmagick++, supports Buffers only.
+* [jimp](https://www.npmjs.com/package/jimp) v0.2.24 - Image processing in pure JavaScript. Bilinear interpolation only.
+* [lwip](https://www.npmjs.com/package/lwip) v0.0.9 - Wrapper around CImg, compiles dependencies from source.
+* [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) v1.9.2 - Wrapper around libmagick++, supports Buffers only.
 * [imagemagick](https://www.npmjs.com/package/imagemagick) v0.1.3 - Supports filesystem only and "*has been unmaintained for a long time*".
-* [gm](https://www.npmjs.com/package/gm) v1.21.0 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
-* sharp v0.13.0 / libvips v8.2.2 - Caching within libvips disabled to ensure a fair comparison.
+* [gm](https://www.npmjs.com/package/gm) v1.22.0 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
+* sharp v0.15.0 / libvips v8.3.1 - Caching within libvips disabled to ensure a fair comparison.
 
 ### The task
 
-Decompress a 2725x2225 JPEG image, resize to 720x480 using bicubic interpolation (where available), then compress to JPEG.
+Decompress a 2725x2225 JPEG image,
+resize to 720x480 using Lanczos 3 resampling (where available),
+then compress to JPEG.
 
 ### Results
 
 | Module             | Input  | Output | Ops/sec | Speed-up |
 | :----------------- | :----- | :----- | ------: | -------: |
-| jimp (bilinear)    | file   | file   |    1.04 |      1.0 |
-| jimp (bilinear)    | buffer | buffer |    1.07 |      1.0 |
-| lwip               | file   | file   |    1.13 |      1.1 |
-| lwip               | buffer | buffer |    1.13 |      1.1 |
-| imagemagick-native | buffer | buffer |    1.65 |      1.6 |
-| imagemagick        | file   | file   |    5.02 |      4.8 |
-| gm                 | buffer | buffer |    5.36 |      5.2 |
-| gm                 | file   | file   |    5.39 |      5.2 |
-| sharp              | stream | stream |   22.00 |     21.2 |
-| sharp              | file   | file   |   22.87 |     22.0 |
-| sharp              | file   | buffer |   23.03 |     22.1 |
-| sharp              | buffer | file   |   23.10 |     22.2 |
-| sharp              | buffer | buffer |   23.21 |     22.3 |
+| jimp (bilinear)    | file   | file   |    0.94 |      1.0 |
+| jimp (bilinear)    | buffer | buffer |    0.98 |      1.0 |
+| lwip               | file   | file   |    1.14 |      1.2 |
+| lwip               | buffer | buffer |    1.14 |      1.2 |
+| imagemagick-native | buffer | buffer |    1.66 |      1.8 |
+| imagemagick        | file   | file   |    5.08 |      5.4 |
+| gm                 | buffer | buffer |    5.43 |      5.7 |
+| gm                 | file   | file   |    5.46 |      5.8 |
+| sharp              | stream | stream |   26.52 |     28.2 |
+| sharp              | file   | file   |   28.16 |     30.0 |
+| sharp              | file   | buffer |   28.27 |     30.1 |
+| sharp              | buffer | file   |   28.42 |     30.2 |
+| sharp              | buffer | buffer |   28.42 |     30.2 |
 
-Greater performance can be expected with caching enabled (default) and using 8+ core machines.
+Greater libvips performance can be expected with caching enabled (default)
+and using 8+ core machines, especially those with larger L1/L2 CPU caches.
 
 The I/O limits of the relevant (de)compression library will generally determine maximum throughput.
 

index.js

@@ -9,7 +9,7 @@ var semver = require('semver');
 var color = require('color');
 var BluebirdPromise = require('bluebird');
 
-var sharp = require('./build/Release/sharp');
+var sharp = require('./build/Release/sharp.node');
 
 // Versioning
 var versions = {
@@ -42,14 +42,8 @@ var Sharp = function(input, options) {
   stream.Duplex.call(this);
   this.options = {
     // input options
-    bufferIn: null,
-    streamIn: false,
     sequentialRead: false,
     limitInputPixels: maximum.pixels,
-    density: 72,
-    rawWidth: 0,
-    rawHeight: 0,
-    rawChannels: 0,
     // ICC profiles
     iccProfilePath: path.join(__dirname, 'icc') + path.sep,
     // resize options
@@ -74,23 +68,31 @@ var Sharp = function(input, options) {
     extendLeft: 0,
     extendRight: 0,
     withoutEnlargement: false,
+    kernel: 'lanczos3',
     interpolator: 'bicubic',
     // operations
     background: [0, 0, 0, 255],
     flatten: false,
     negate: false,
     blurSigma: 0,
-    sharpenRadius: 0,
+    sharpenSigma: 0,
     sharpenFlat: 1,
     sharpenJagged: 2,
     threshold: 0,
+    thresholdGrayscale: true,
+    trimTolerance: 0,
     gamma: 0,
     greyscale: false,
     normalize: 0,
+    booleanBufferIn: null,
+    booleanFileIn: '',
+    joinChannelIn: [],
     // overlay
-    overlayFileIn: '',
-    overlayBufferIn: null,
     overlayGravity: 0,
+    overlayXOffset : -1,
+    overlayYOffset : -1,
+    overlayTile: false,
+    overlayCutout: false,
     // output options
     formatOut: 'input',
     fileOut: '',
@@ -107,24 +109,14 @@ var Sharp = function(input, options) {
     withMetadataOrientation: -1,
     tileSize: 256,
     tileOverlap: 0,
+    extractChannel: -1,
+    colourspace: 'srgb',
     // Function to notify of queue length changes
     queueListener: function(queueLength) {
       module.exports.queue.emit('change', queueLength);
     }
   };
-  if (isString(input)) {
-    // input=file
-    this.options.fileIn = input;
-  } else if (isBuffer(input)) {
-    // input=buffer
-    this.options.bufferIn = input;
-  } else if (!isDefined(input)) {
-    // input=stream
-    this.options.streamIn = true;
-  } else {
-    throw new Error('Unsupported input ' + typeof input);
-  }
-  this._inputOptions(options);
+  this.options.input = this._createInputDescriptor(input, options, { allowStream: true });
   return this;
 };
 module.exports = Sharp;
@@ -154,14 +146,20 @@ var isDefined = function(val) {
 var isObject = function(val) {
   return typeof val === 'object';
 };
+var isBoolean = function(val) {
+  return typeof val === 'boolean';
+};
 var isBuffer = function(val) {
   return typeof val === 'object' && val instanceof Buffer;
 };
 var isString = function(val) {
   return typeof val === 'string' && val.length > 0;
 };
+var isNumber = function(val) {
+  return typeof val === 'number' && !Number.isNaN(val);
+};
 var isInteger = function(val) {
-  return typeof val === 'number' && !Number.isNaN(val) && val % 1 === 0;
+  return isNumber(val) && val % 1 === 0;
 };
 var inRange = function(val, min, max) {
   return val >= min && val <= max;
@@ -171,37 +169,50 @@ var contains = function(val, list) {
 };
 
 /*
-  Set input-related options
-    density: DPI at which to load vector images via libmagick
+  Create Object containing input and input-related options
 */
-Sharp.prototype._inputOptions = function(options) {
-  if (isObject(options)) {
+Sharp.prototype._createInputDescriptor = function(input, inputOptions, containerOptions) {
+  var inputDescriptor = {};
+  if (isString(input)) {
+    // filesystem
+    inputDescriptor.file = input;
+  } else if (isBuffer(input)) {
+    // Buffer
+    inputDescriptor.buffer = input;
+  } else if (!isDefined(input) && isObject(containerOptions) && containerOptions.allowStream) {
+    // Stream
+    inputDescriptor.buffer = [];
+  } else {
+    throw new Error('Unsupported input ' + typeof input);
+  }
+  if (isObject(inputOptions)) {
     // Density
-    if (isDefined(options.density)) {
-      if (isInteger(options.density) && inRange(options.density, 1, 2400)) {
-        this.options.density = options.density;
+    if (isDefined(inputOptions.density)) {
+      if (isInteger(inputOptions.density) && inRange(inputOptions.density, 1, 2400)) {
+        inputDescriptor.density = inputOptions.density;
       } else {
-        throw new Error('Invalid density (1 to 2400) ' + options.density);
+        throw new Error('Invalid density (1 to 2400) ' + inputOptions.density);
       }
     }
     // Raw pixel input
-    if (isDefined(options.raw)) {
+    if (isDefined(inputOptions.raw)) {
       if (
-        isObject(options.raw) &&
-        isInteger(options.raw.width) && inRange(options.raw.width, 1, maximum.width) &&
-        isInteger(options.raw.height) && inRange(options.raw.height, 1, maximum.height) &&
-        isInteger(options.raw.channels) && inRange(options.raw.channels, 1, 4)
+        isObject(inputOptions.raw) &&
+        isInteger(inputOptions.raw.width) && inRange(inputOptions.raw.width, 1, maximum.width) &&
+        isInteger(inputOptions.raw.height) && inRange(inputOptions.raw.height, 1, maximum.height) &&
+        isInteger(inputOptions.raw.channels) && inRange(inputOptions.raw.channels, 1, 4)
       ) {
-        this.options.rawWidth = options.raw.width;
-        this.options.rawHeight = options.raw.height;
-        this.options.rawChannels = options.raw.channels;
+        inputDescriptor.rawWidth = inputOptions.raw.width;
+        inputDescriptor.rawHeight = inputOptions.raw.height;
+        inputDescriptor.rawChannels = inputOptions.raw.channels;
       } else {
         throw new Error('Expected width, height and channels for raw pixel input');
       }
     }
-  } else if (isDefined(options)) {
-    throw new Error('Invalid input options ' + options);
+  } else if (isDefined(inputOptions)) {
+    throw new Error('Invalid input options ' + inputOptions);
   }
+  return inputDescriptor;
 };
 
 /*
@@ -209,19 +220,9 @@ Sharp.prototype._inputOptions = function(options) {
 */
 Sharp.prototype._write = function(chunk, encoding, callback) {
   /*jslint unused: false */
-  if (this.options.streamIn) {
-    if (typeof chunk === 'object' && chunk instanceof Buffer) {
-      if (this.options.bufferIn instanceof Buffer) {
-        // Append to existing Buffer
-        this.options.bufferIn = Buffer.concat(
-          [this.options.bufferIn, chunk],
-          this.options.bufferIn.length + chunk.length
-        );
-      } else {
-        // Create new Buffer
-        this.options.bufferIn = new Buffer(chunk.length);
-        chunk.copy(this.options.bufferIn);
-      }
+  if (Array.isArray(this.options.input.buffer)) {
+    if (isBuffer(chunk)) {
+      this.options.input.buffer.push(chunk);
       callback();
     } else {
       callback(new Error('Non-Buffer data on Writable Stream'));
@@ -231,6 +232,18 @@ Sharp.prototype._write = function(chunk, encoding, callback) {
   }
 };
 
+/*
+  Flattens the array of chunks accumulated in input.buffer
+*/
+Sharp.prototype._flattenBufferIn = function() {
+  if (this._isStreamInput()) {
+    this.options.input.buffer = Buffer.concat(this.options.input.buffer);
+  }
+};
+Sharp.prototype._isStreamInput = function() {
+  return Array.isArray(this.options.input.buffer);
+};
+
 // Weighting to apply to image crop
 module.exports.gravity = {
   center: 0,
@@ -247,7 +260,8 @@ module.exports.gravity = {
 
 // Strategies for automagic behaviour
 module.exports.strategy = {
-  entropy: 16
+  entropy: 16,
+  attention: 17
 };
 
 /*
@@ -264,7 +278,7 @@ Sharp.prototype.crop = function(crop) {
   } else if (isString(crop) && isInteger(module.exports.gravity[crop])) {
     // Gravity (string)
     this.options.crop = module.exports.gravity[crop];
-  } else if (isInteger(crop) && crop === module.exports.strategy.entropy) {
+  } else if (isInteger(crop) && crop >= module.exports.strategy.entropy) {
     // Strategy
     this.options.crop = crop;
   } else {
@@ -290,6 +304,21 @@ Sharp.prototype.extract = function(options) {
   return this;
 };
 
+Sharp.prototype.extractChannel = function(channel) {
+  if (channel === 'red')
+    channel = 0;
+  else if (channel === 'green')
+    channel = 1;
+  else if (channel === 'blue')
+    channel = 2;
+  if(isInteger(channel) && inRange(channel,0,4)) {
+    this.options.extractChannel = channel;
+  } else {
+    throw new Error('Cannot extract invalid channel ' + channel);
+  }
+  return this;
+};
+
 /*
   Set the background colour for embed and flatten operations.
   Delegates to the 'Color' module, which can throw an Error
@@ -327,12 +356,25 @@ Sharp.prototype.ignoreAspectRatio = function() {
 };
 
 Sharp.prototype.flatten = function(flatten) {
-  this.options.flatten = (typeof flatten === 'boolean') ? flatten : true;
+  this.options.flatten = isBoolean(flatten) ? flatten : true;
   return this;
 };
 
 Sharp.prototype.negate = function(negate) {
-  this.options.negate = (typeof negate === 'boolean') ? negate : true;
+  this.options.negate = isBoolean(negate) ? negate : true;
+  return this;
+};
+
+/*
+  Bitwise boolean operations between images
+*/
+Sharp.prototype.boolean = function(operand, operator, options) {
+  this.options.boolean = this._createInputDescriptor(operand, options);
+  if (isString(operator) && contains(operator, ['and', 'or', 'eor'])) {
+    this.options.booleanOp = operator;
+  } else {
+    throw new Error('Invalid boolean operation ' + operator);
+  }
   return this;
 };
 
@@ -340,21 +382,58 @@ Sharp.prototype.negate = function(negate) {
   Overlay with another image, using an optional gravity
 */
 Sharp.prototype.overlayWith = function(overlay, options) {
-  if (isString(overlay)) {
-    this.options.overlayFileIn = overlay;
-  } else if (isBuffer(overlay)) {
-    this.options.overlayBufferIn = overlay;
-  } else {
-    throw new Error('Unsupported overlay ' + typeof overlay);
-  }
+  this.options.overlay = this._createInputDescriptor(overlay, options, {
+    allowStream: false
+  });
   if (isObject(options)) {
-    if (isInteger(options.gravity) && inRange(options.gravity, 0, 8)) {
-      this.options.overlayGravity = options.gravity;
-    } else if (isString(options.gravity) && isInteger(module.exports.gravity[options.gravity])) {
-      this.options.overlayGravity = module.exports.gravity[options.gravity];
-    } else if (isDefined(options.gravity)) {
-      throw new Error('Unsupported overlay gravity ' + options.gravity);
+    if (isDefined(options.tile)) {
+      if (isBoolean(options.tile)) {
+        this.options.overlayTile = options.tile;
+      } else {
+        throw new Error('Invalid overlay tile ' + options.tile);
+      }
     }
+    if (isDefined(options.cutout)) {
+      if (isBoolean(options.cutout)) {
+        this.options.overlayCutout = options.cutout;
+      } else {
+        throw new Error('Invalid overlay cutout ' + options.cutout);
+      }
+    }
+    if (isDefined(options.left) || isDefined(options.top)) {
+      if (
+        isInteger(options.left) && inRange(options.left, 0, maximum.width) &&
+        isInteger(options.top) && inRange(options.top, 0, maximum.height)
+      ) {
+        this.options.overlayXOffset = options.left;
+        this.options.overlayYOffset = options.top;
+      } else {
+        throw new Error('Invalid overlay left ' + options.left + ' and/or top ' + options.top);
+      }
+    }
+    if (isDefined(options.gravity)) {
+      if(isInteger(options.gravity) && inRange(options.gravity, 0, 8)) {
+        this.options.overlayGravity = options.gravity;
+      } else if (isString(options.gravity) && isInteger(module.exports.gravity[options.gravity])) {
+        this.options.overlayGravity = module.exports.gravity[options.gravity];
+      } else {
+        throw new Error('Unsupported overlay gravity ' + options.gravity);
+      }
+    }
+  }
+  return this;
+};
+
+/*
+  Add another color channel to the image
+*/
+Sharp.prototype.joinChannel = function(images, options) {
+  if (Array.isArray(images)) {
+    images.forEach(function(image) {
+      this.options.joinChannelIn.push(this._createInputDescriptor(image, options));
+    }, this);
+  } else {
+    this.options.joinChannelIn.push(this._createInputDescriptor(images, options));
   }
   return this;
 };
@@ -364,9 +443,9 @@ Sharp.prototype.overlayWith = function(overlay, options) {
   Auto-rotation based on the EXIF Orientation tag is represented by an angle of -1
 */
 Sharp.prototype.rotate = function(angle) {
-  if (typeof angle === 'undefined') {
+  if (!isDefined(angle)) {
     this.options.angle = -1;
-  } else if (!Number.isNaN(angle) && [0, 90, 180, 270].indexOf(angle) !== -1) {
+  } else if (isInteger(angle) && contains(angle, [0, 90, 180, 270])) {
     this.options.angle = angle;
   } else {
     throw new Error('Unsupported angle (0, 90, 180, 270) ' + angle);
@@ -378,7 +457,7 @@ Sharp.prototype.rotate = function(angle) {
   Flip the image vertically, about the Y axis
 */
 Sharp.prototype.flip = function(flip) {
-  this.options.flip = (typeof flip === 'boolean') ? flip : true;
+  this.options.flip = isBoolean(flip) ? flip : true;
   return this;
 };
 
@@ -386,7 +465,7 @@ Sharp.prototype.flip = function(flip) {
   Flop the image horizontally, about the X axis
 */
 Sharp.prototype.flop = function(flop) {
-  this.options.flop = (typeof flop === 'boolean') ? flop : true;
+  this.options.flop = isBoolean(flop) ? flop : true;
   return this;
 };
 
@@ -396,7 +475,7 @@ Sharp.prototype.flop = function(flop) {
     "change the dimensions of the image only if its width or height exceeds the geometry specification"
 */
 Sharp.prototype.withoutEnlargement = function(withoutEnlargement) {
-  this.options.withoutEnlargement = (typeof withoutEnlargement === 'boolean') ? withoutEnlargement : true;
+  this.options.withoutEnlargement = isBoolean(withoutEnlargement) ? withoutEnlargement : true;
   return this;
 };
 
@@ -406,97 +485,120 @@ Sharp.prototype.withoutEnlargement = function(withoutEnlargement) {
   Call with a sigma to use a slower, more accurate Gaussian blur.
 */
 Sharp.prototype.blur = function(sigma) {
-  if (typeof sigma === 'undefined') {
+  if (!isDefined(sigma)) {
     // No arguments: default to mild blur
     this.options.blurSigma = -1;
-  } else if (typeof sigma === 'boolean') {
+  } else if (isBoolean(sigma)) {
     // Boolean argument: apply mild blur?
     this.options.blurSigma = sigma ? -1 : 0;
-  } else if (typeof sigma === 'number' && !Number.isNaN(sigma) && sigma >= 0.3 && sigma <= 1000) {
+  } else if (isNumber(sigma) && inRange(sigma, 0.3, 1000)) {
     // Numeric argument: specific sigma
     this.options.blurSigma = sigma;
   } else {
-    throw new Error('Invalid blur sigma (0.3 to 1000.0) ' + sigma);
+    throw new Error('Invalid blur sigma (0.3 - 1000.0) ' + sigma);
   }
   return this;
 };
 
+/*
+  Convolve the image with a kernel.
+*/
+Sharp.prototype.convolve = function(kernel) {
+  if (!isObject(kernel) || !Array.isArray(kernel.kernel) ||
+      !isInteger(kernel.width) || !isInteger(kernel.height) ||
+      !inRange(kernel.width, 3, 1001) || !inRange(kernel.height, 3, 1001) ||
+      kernel.height * kernel.width != kernel.kernel.length
+     ) {
+    // must pass in a kernel
+    throw new Error('Invalid convolution kernel');
+  }
+  // Default scale is sum of kernel values
+  if (!isInteger(kernel.scale)) {
+    kernel.scale = kernel.kernel.reduce(function(a, b) {
+      return a + b;
+    }, 0);
+  }
+  // Clamp scale to a minimum value of 1
+  if (kernel.scale < 1) {
+    kernel.scale = 1;
+  }
+  if (!isInteger(kernel.offset)) {
+    kernel.offset = 0;
+  }
+  this.options.convKernel = kernel;
+  return this;
+};
+
 /*
   Sharpen the output image.
   Call without a radius to use a fast, mild sharpen.
   Call with a radius to use a slow, accurate sharpen using the L of LAB colour space.
-    radius - size of mask in pixels, must be integer
+    sigma - sigma of mask
     flat - level of "flat" area sharpen, default 1
     jagged - level of "jagged" area sharpen, default 2
 */
-Sharp.prototype.sharpen = function(radius, flat, jagged) {
-  if (typeof radius === 'undefined') {
+Sharp.prototype.sharpen = function(sigma, flat, jagged) {
+  if (!isDefined(sigma)) {
     // No arguments: default to mild sharpen
-    this.options.sharpenRadius = -1;
-  } else if (typeof radius === 'boolean') {
+    this.options.sharpenSigma = -1;
+  } else if (isBoolean(sigma)) {
     // Boolean argument: apply mild sharpen?
-    this.options.sharpenRadius = radius ? -1 : 0;
-  } else if (typeof radius === 'number' && !Number.isNaN(radius) && (radius % 1 === 0) && radius >= 1) {
-    // Numeric argument: specific radius
-    this.options.sharpenRadius = radius;
+    this.options.sharpenSigma = sigma ? -1 : 0;
+  } else if (isNumber(sigma) && inRange(sigma, 0.01, 10000)) {
+    // Numeric argument: specific sigma
+    this.options.sharpenSigma = sigma;
     // Control over flat areas
-    if (typeof flat !== 'undefined' && flat !== null) {
-      if (typeof flat === 'number' && !Number.isNaN(flat) && flat >= 0) {
+    if (isDefined(flat)) {
+      if (isNumber(flat) && inRange(flat, 0, 10000)) {
         this.options.sharpenFlat = flat;
       } else {
-        throw new Error('Invalid sharpen level for flat areas ' + flat + ' (expected >= 0)');
+        throw new Error('Invalid sharpen level for flat areas (0 - 10000) ' + flat);
       }
     }
     // Control over jagged areas
-    if (typeof jagged !== 'undefined' && jagged !== null) {
-      if (typeof jagged === 'number' && !Number.isNaN(jagged) && jagged >= 0) {
+    if (isDefined(jagged)) {
+      if (isNumber(jagged) && inRange(jagged, 0, 10000)) {
         this.options.sharpenJagged = jagged;
       } else {
-        throw new Error('Invalid sharpen level for jagged areas ' + jagged + ' (expected >= 0)');
+        throw new Error('Invalid sharpen level for jagged areas (0 - 10000) ' + jagged);
       }
     }
   } else {
-    throw new Error('Invalid sharpen radius ' + radius + ' (expected integer >= 1)');
+    throw new Error('Invalid sharpen sigma (0.01 - 10000) ' + sigma);
   }
   return this;
 };
 
-Sharp.prototype.threshold = function(threshold) {
-  if (typeof threshold === 'undefined') {
+Sharp.prototype.threshold = function(threshold, options) {
+  if (!isDefined(threshold)) {
     this.options.threshold = 128;
-  } else if (typeof threshold === 'boolean') {
+  } else if (isBoolean(threshold)) {
     this.options.threshold = threshold ? 128 : 0;
-  } else if (typeof threshold === 'number' && !Number.isNaN(threshold) && (threshold % 1 === 0) && threshold >= 0 && threshold <= 255) {
+  } else if (isInteger(threshold) && inRange(threshold, 0, 255)) {
     this.options.threshold = threshold;
   } else {
     throw new Error('Invalid threshold (0 to 255) ' + threshold);
   }
+  if (!isObject(options) || options.greyscale === true || options.grayscale === true) {
+    this.options.thresholdGrayscale = true;
+  } else {
+    this.options.thresholdGrayscale = false;
+  }
   return this;
 };
 
 /*
-  Set the interpolator to use for the affine transformation
-*/
-module.exports.interpolator = {
-  nearest: 'nearest',
-  bilinear: 'bilinear',
-  bicubic: 'bicubic',
-  nohalo: 'nohalo',
-  locallyBoundedBicubic: 'lbb',
-  vertexSplitQuadraticBasisSpline: 'vsqbs'
-};
-Sharp.prototype.interpolateWith = function(interpolator) {
-  var isValid = false;
-  for (var key in module.exports.interpolator) {
-    if (module.exports.interpolator[key] === interpolator) {
-      isValid = true;
-      break;
-    }
-  }
-  if (isValid) {
-    this.options.interpolator = interpolator;
+  Automatically remove "boring" image edges.
+    tolerance - if present, is a percentaged tolerance level between 0 and 100 to trim away similar color values
+      Defaulting to 10 when no tolerance is given.
+ */
+Sharp.prototype.trim = function(tolerance) {
+  if (!isDefined(tolerance)) {
+    this.options.trimTolerance = 10;
+  } else if (isInteger(tolerance) && inRange(tolerance, 1, 99)) {
+    this.options.trimTolerance = tolerance;
   } else {
-    throw new Error('Invalid interpolator ' + interpolator);
+    throw new Error('Invalid trim tolerance (1 to 99) ' + tolerance);
   }
   return this;
 };
@@ -506,10 +608,10 @@ Sharp.prototype.interpolateWith = function(interpolator) {
   Improves brightness of resized image in non-linear colour spaces.
 */
 Sharp.prototype.gamma = function(gamma) {
-  if (typeof gamma === 'undefined') {
+  if (!isDefined(gamma)) {
     // Default gamma correction of 2.2 (sRGB)
     this.options.gamma = 2.2;
-  } else if (!Number.isNaN(gamma) && gamma >= 1 && gamma <= 3) {
+  } else if (isNumber(gamma) && inRange(gamma, 1, 3)) {
     this.options.gamma = gamma;
   } else {
     throw new Error('Invalid gamma correction (1.0 to 3.0) ' + gamma);
@@ -521,32 +623,56 @@ Sharp.prototype.gamma = function(gamma) {
   Enhance output image contrast by stretching its luminance to cover the full dynamic range
 */
 Sharp.prototype.normalize = function(normalize) {
-  this.options.normalize = (typeof normalize === 'boolean') ? normalize : true;
+  this.options.normalize = isBoolean(normalize) ? normalize : true;
   return this;
 };
 Sharp.prototype.normalise = Sharp.prototype.normalize;
 
+/*
+  Perform boolean/bitwise operation on image color channels - results in one channel image
+*/
+Sharp.prototype.bandbool = function(boolOp) {
+  if (isString(boolOp) && contains(boolOp, ['and', 'or', 'eor'])) {
+    this.options.bandBoolOp = boolOp;
+  } else {
+    throw new Error('Invalid bandbool operation ' + boolOp);
+  }
+  return this;
+};
+
 /*
   Convert to greyscale
 */
 Sharp.prototype.greyscale = function(greyscale) {
-  this.options.greyscale = (typeof greyscale === 'boolean') ? greyscale : true;
+  this.options.greyscale = isBoolean(greyscale) ? greyscale : true;
   return this;
 };
 Sharp.prototype.grayscale = Sharp.prototype.greyscale;
 
+/*
+  Set output colourspace
+*/
+Sharp.prototype.toColourspace = function(colourspace) {
+  if (!isString(colourspace) ) {
+    throw new Error('Invalid output colourspace ' + colourspace);
+  }
+  this.options.colourspace = colourspace;
+  return this;
+};
+Sharp.prototype.toColorspace = Sharp.prototype.toColourspace;
+
 Sharp.prototype.progressive = function(progressive) {
-  this.options.progressive = (typeof progressive === 'boolean') ? progressive : true;
+  this.options.progressive = isBoolean(progressive) ? progressive : true;
   return this;
 };
 
 Sharp.prototype.sequentialRead = function(sequentialRead) {
-  this.options.sequentialRead = (typeof sequentialRead === 'boolean') ? sequentialRead : true;
+  this.options.sequentialRead = isBoolean(sequentialRead) ? sequentialRead : true;
   return this;
 };
 
 Sharp.prototype.quality = function(quality) {
-  if (!Number.isNaN(quality) && quality >= 1 && quality <= 100 && quality % 1 === 0) {
+  if (isInteger(quality) && inRange(quality, 1, 100)) {
     this.options.quality = quality;
   } else {
     throw new Error('Invalid quality (1 to 100) ' + quality);
@@ -558,7 +684,7 @@ Sharp.prototype.quality = function(quality) {
   zlib compression level for PNG output
 */
 Sharp.prototype.compressionLevel = function(compressionLevel) {
-  if (!Number.isNaN(compressionLevel) && compressionLevel >= 0 && compressionLevel <= 9) {
+  if (isInteger(compressionLevel) && inRange(compressionLevel, 0, 9)) {
     this.options.compressionLevel = compressionLevel;
   } else {
     throw new Error('Invalid compressionLevel (0 to 9) ' + compressionLevel);
@@ -570,7 +696,7 @@ Sharp.prototype.compressionLevel = function(compressionLevel) {
   Disable the use of adaptive row filtering for PNG output
 */
 Sharp.prototype.withoutAdaptiveFiltering = function(withoutAdaptiveFiltering) {
-  this.options.withoutAdaptiveFiltering = (typeof withoutAdaptiveFiltering === 'boolean') ? withoutAdaptiveFiltering : true;
+  this.options.withoutAdaptiveFiltering = isBoolean(withoutAdaptiveFiltering) ? withoutAdaptiveFiltering : true;
   return this;
 };
 
@@ -578,7 +704,7 @@ Sharp.prototype.withoutAdaptiveFiltering = function(withoutAdaptiveFiltering) {
   Disable the use of chroma subsampling for JPEG output
 */
 Sharp.prototype.withoutChromaSubsampling = function(withoutChromaSubsampling) {
-  this.options.withoutChromaSubsampling = (typeof withoutChromaSubsampling === 'boolean') ? withoutChromaSubsampling : true;
+  this.options.withoutChromaSubsampling = isBoolean(withoutChromaSubsampling) ? withoutChromaSubsampling : true;
   return this;
 };
 
@@ -586,7 +712,7 @@ Sharp.prototype.withoutChromaSubsampling = function(withoutChromaSubsampling) {
   Apply trellis quantisation to JPEG output - requires mozjpeg 3.0+
 */
 Sharp.prototype.trellisQuantisation = function(trellisQuantisation) {
-  this.options.trellisQuantisation = (typeof trellisQuantisation === 'boolean') ? trellisQuantisation : true;
+  this.options.trellisQuantisation = isBoolean(trellisQuantisation) ? trellisQuantisation : true;
   return this;
 };
 Sharp.prototype.trellisQuantization = Sharp.prototype.trellisQuantisation;
@@ -595,7 +721,7 @@ Sharp.prototype.trellisQuantization = Sharp.prototype.trellisQuantisation;
   Apply overshoot deringing to JPEG output - requires mozjpeg 3.0+
 */
 Sharp.prototype.overshootDeringing = function(overshootDeringing) {
-  this.options.overshootDeringing = (typeof overshootDeringing === 'boolean') ? overshootDeringing : true;
+  this.options.overshootDeringing = isBoolean(overshootDeringing) ? overshootDeringing : true;
   return this;
 };
 
@@ -603,7 +729,7 @@ Sharp.prototype.overshootDeringing = function(overshootDeringing) {
   Optimise scans in progressive JPEG output - requires mozjpeg 3.0+
 */
 Sharp.prototype.optimiseScans = function(optimiseScans) {
-  this.options.optimiseScans = (typeof optimiseScans === 'boolean') ? optimiseScans : true;
+  this.options.optimiseScans = isBoolean(optimiseScans) ? optimiseScans : true;
   if (this.options.optimiseScans) {
     this.progressive();
   }
@@ -617,16 +743,10 @@ Sharp.prototype.optimizeScans = Sharp.prototype.optimiseScans;
     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 >= 1 &&
-        withMetadata.orientation <= 8
-      ) {
+  this.options.withMetadata = isBoolean(withMetadata) ? withMetadata : true;
+  if (isObject(withMetadata)) {
+    if (isDefined(withMetadata.orientation)) {
+      if (isInteger(withMetadata.orientation) && inRange(withMetadata.orientation, 1, 8)) {
         this.options.withMetadataOrientation = withMetadata.orientation;
       } else {
         throw new Error('Invalid orientation (1 to 8) ' + withMetadata.orientation);
@@ -660,6 +780,14 @@ Sharp.prototype.tile = function(tile) {
         throw new Error('Invalid tile overlap (0 to 8192) ' + tile.overlap);
       }
     }
+    // Container
+    if (isDefined(tile.container)) {
+      if (isString(tile.container) && contains(tile.container, ['fs', 'zip'])) {
+        this.options.tileContainer = tile.container;
+      } else {
+        throw new Error('Invalid tile container ' + tile.container);
+      }
+    }
     // Layout
     if (isDefined(tile.layout)) {
       if (isString(tile.layout) && contains(tile.layout, ['dz', 'google', 'zoomify'])) {
@@ -698,34 +826,97 @@ Sharp.prototype.extend = function(extend) {
   return this;
 };
 
-Sharp.prototype.resize = function(width, height) {
-  if (!width) {
-    this.options.width = -1;
-  } else {
-    if (typeof width === 'number' && !Number.isNaN(width) && width % 1 === 0 && width > 0 && width <= maximum.width) {
+// Kernels for reduction
+module.exports.kernel = {
+  cubic: 'cubic',
+  lanczos2: 'lanczos2',
+  lanczos3: 'lanczos3'
+};
+// Interpolators for enlargement
+module.exports.interpolator = {
+  nearest: 'nearest',
+  bilinear: 'bilinear',
+  bicubic: 'bicubic',
+  nohalo: 'nohalo',
+  lbb: 'lbb',
+  locallyBoundedBicubic: 'lbb',
+  vsqbs: 'vsqbs',
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+// Boolean operations for bandbool
+module.exports.bool = {
+  and: 'and',
+  or: 'or',
+  eor: 'eor'
+};
+// Colourspaces
+module.exports.colourspace = {
+  multiband: 'multiband',
+  'b-w': 'b-w',
+  bw: 'b-w',
+  cmyk: 'cmyk',
+  srgb: 'srgb'
+};
+module.exports.colorspace = module.exports.colourspace;
+
+/*
+  Resize image to width x height pixels
+  options.kernel is the kernel to use for reductions, default 'lanczos3'
+  options.interpolator is the interpolator to use for enlargements, default 'bicubic'
+*/
+Sharp.prototype.resize = function(width, height, options) {
+  if (isDefined(width)) {
+    if (isInteger(width) && inRange(width, 1, maximum.width)) {
       this.options.width = width;
     } else {
       throw new Error('Invalid width (1 to ' + maximum.width + ') ' + width);
     }
-  }
-  if (!height) {
-    this.options.height = -1;
   } else {
-    if (typeof height === 'number' && !Number.isNaN(height) && height % 1 === 0 && height > 0 && height <= maximum.height) {
+    this.options.width = -1;
+  }
+  if (isDefined(height)) {
+    if (isInteger(height) && inRange(height, 1, maximum.height)) {
       this.options.height = height;
     } else {
       throw new Error('Invalid height (1 to ' + maximum.height + ') ' + height);
     }
+  } else {
+    this.options.height = -1;
+  }
+  if (isObject(options)) {
+    // Kernel
+    if (isDefined(options.kernel)) {
+      if (isString(module.exports.kernel[options.kernel])) {
+        this.options.kernel = module.exports.kernel[options.kernel];
+      } else {
+        throw new Error('Invalid kernel ' + options.kernel);
+      }
+    }
+    // Interpolator
+    if (isDefined(options.interpolator)) {
+      if (isString(module.exports.interpolator[options.interpolator])) {
+        this.options.interpolator = module.exports.interpolator[options.interpolator];
+      } else {
+        throw new Error('Invalid interpolator ' + options.interpolator);
+      }
+    }
   }
   return this;
 };
 
 /*
   Limit the total number of pixels for input images
-  Assumes the image dimensions contained in the file header can be trusted
+  Assumes the image dimensions contained in the file header can be trusted.
+  Alternatively can use boolean to disable or reset to default (maximum pixels)
 */
 Sharp.prototype.limitInputPixels = function(limit) {
-  if (typeof limit === 'number' && !Number.isNaN(limit) && limit % 1 === 0 && limit > 0) {
+  //if we pass in false we represent the integer as 0 to disable
+  if(limit === false) {
+    limit = 0;
+  } else if(limit === true) {
+    limit = maximum.pixels;
+  }
+  if (typeof limit === 'number' && !Number.isNaN(limit) && limit % 1 === 0 && limit >= 0) {
     this.options.limitInputPixels = limit;
   } else {
     throw new Error('Invalid pixel limit (1 to ' + maximum.pixels + ') ' + limit);
@@ -745,7 +936,7 @@ Sharp.prototype.toFile = function(fileOut, callback) {
       return BluebirdPromise.reject(errOutputInvalid);
     }
   } else {
-    if (this.options.fileIn === fileOut) {
+    if (this.options.input.file === fileOut) {
       var errOutputIsInput = new Error('Cannot use same file for input and output');
       if (typeof callback === 'function') {
         callback(errOutputIsInput);
@@ -804,12 +995,11 @@ Sharp.prototype.raw = function() {
   @param format is either the id as a String or an Object with an 'id' attribute
 */
 Sharp.prototype.toFormat = function(formatOut) {
-  if (isObject(formatOut) && isDefined(formatOut.id)) {
-    formatOut = formatOut.id;
-  }
-  if (
-    isDefined(formatOut) &&
-    ['jpeg', 'png', 'webp', 'raw', 'tiff', 'dz', 'input'].indexOf(formatOut) !== -1
+  if (isObject(formatOut) && isString(formatOut.id)) {
+    this.options.formatOut = formatOut.id;
+  } else if (
+    isString(formatOut) &&
+    contains(formatOut, ['jpeg', 'png', 'webp', 'raw', 'tiff', 'dz', 'input'])
   ) {
     this.options.formatOut = formatOut;
   } else {
@@ -836,9 +1026,10 @@ Sharp.prototype._pipeline = function(callback) {
   var that = this;
   if (typeof callback === 'function') {
     // output=file/buffer
-    if (this.options.streamIn) {
+    if (this._isStreamInput()) {
       // output=file/buffer, input=stream
       this.on('finish', function() {
+        that._flattenBufferIn();
         sharp.pipeline(that.options, callback);
       });
     } else {
@@ -848,9 +1039,10 @@ Sharp.prototype._pipeline = function(callback) {
     return this;
   } else if (this.options.streamOut) {
     // output=stream
-    if (this.options.streamIn) {
+    if (this._isStreamInput()) {
       // output=stream, input=stream
       this.on('finish', function() {
+        that._flattenBufferIn();
         sharp.pipeline(that.options, function(err, data, info) {
           if (err) {
             that.emit('error', err);
@@ -876,10 +1068,11 @@ Sharp.prototype._pipeline = function(callback) {
     return this;
   } else {
     // output=promise
-    if (this.options.streamIn) {
+    if (this._isStreamInput()) {
       // output=promise, input=stream
       return new BluebirdPromise(function(resolve, reject) {
         that.on('finish', function() {
+          that._flattenBufferIn();
           sharp.pipeline(that.options, function(err, data) {
             if (err) {
               reject(err);
@@ -911,8 +1104,9 @@ Sharp.prototype._pipeline = function(callback) {
 Sharp.prototype.metadata = function(callback) {
   var that = this;
   if (typeof callback === 'function') {
-    if (this.options.streamIn) {
+    if (this._isStreamInput()) {
       this.on('finish', function() {
+        that._flattenBufferIn();
         sharp.metadata(that.options, callback);
       });
     } else {
@@ -920,9 +1114,10 @@ Sharp.prototype.metadata = function(callback) {
     }
     return this;
   } else {
-    if (this.options.streamIn) {
+    if (this._isStreamInput()) {
       return new BluebirdPromise(function(resolve, reject) {
         that.on('finish', function() {
+          that._flattenBufferIn();
           sharp.metadata(that.options, function(err, metadata) {
             if (err) {
               reject(err);
@@ -951,13 +1146,15 @@ Sharp.prototype.metadata = function(callback) {
   Cloned instances share the same input.
 */
 Sharp.prototype.clone = function() {
+  var that = this;
   // Clone existing options
   var clone = new Sharp();
   util._extend(clone.options, this.options);
   // Pass 'finish' event to clone for Stream-based input
   this.on('finish', function() {
     // Clone inherits input data
-    clone.options.bufferIn = this.options.bufferIn;
+    that._flattenBufferIn();
+    clone.options.bufferIn = that.options.bufferIn;
     clone.emit('finish');
   });
   return clone;

mkdocs.yml

@@ -1,7 +1,7 @@
 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.
+site_description: High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images
 copyright: <a href="https://dimens.io/">dimens.io</a>
 google_analytics: ['UA-13034748-12', 'sharp.dimens.io']
 theme: readthedocs

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharp",
-  "version": "0.14.0",
+  "version": "0.16.1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "contributors": [
     "Pierre Inglebert <pierre.inglebert@gmail.com>",
@@ -19,15 +19,23 @@
     "Bernhard K. Weisshuhn <bkw@codingforce.com>",
     "Chris Riley <criley@primedia.com>",
     "David Carley <dacarley@gmail.com>",
-    "John Tobin <john@limelightmobileinc.com>"
+    "John Tobin <john@limelightmobileinc.com>",
+    "Kenton Gray <kentongray@gmail.com>",
+    "Felix Bünemann <Felix.Buenemann@gmail.com>",
+    "Samy Al Zahrani <samyalzahrany@gmail.com>",
+    "Chintan Thakkar <lemnisk8@gmail.com>",
+    "F. Orlando Galashan <frulo@gmx.de>",
+    "Kleis Auke Wolthuizen <info@kleisauke.nl>",
+    "Matt Hirsch <mhirsch@media.mit.edu>",
+    "Matthias Thoemmes <thoemmes@gmail.com>"
   ],
-  "description": "High performance Node.js module to resize JPEG, PNG, WebP and TIFF images using the libvips library",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images",
   "scripts": {
     "clean": "rm -rf node_modules/ build/ include/ lib/ coverage/ test/fixtures/output.*",
     "test": "VIPS_WARNING=0 node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- --slow=5000 --timeout=30000 ./test/unit/*.js",
-    "test-win": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=30000 ./test/unit/*.js",
+    "test-win": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=60000 ./test/unit/*.js",
     "test-leak": "./test/leak/leak.sh",
-    "test-packaging": "./packaging/test.sh",
+    "test-packaging": "./packaging/test-linux-x64.sh",
     "test-clean": "rm -rf coverage/ test/fixtures/output.* && npm install && npm test"
   },
   "main": "index.js",
@@ -40,7 +48,10 @@
     "png",
     "webp",
     "tiff",
+    "gif",
+    "svg",
     "dzi",
+    "image",
     "resize",
     "thumbnail",
     "crop",
@@ -48,28 +59,29 @@
     "vips"
   ],
   "dependencies": {
-    "bluebird": "^3.3.4",
-    "color": "^0.11.1",
-    "nan": "^2.2.1",
-    "semver": "^5.1.0",
-    "request": "^2.69.0",
+    "bluebird": "^3.4.6",
+    "color": "^0.11.3",
+    "nan": "^2.4.0",
+    "semver": "^5.3.0",
+    "request": "^2.75.0",
     "tar": "^2.2.1"
   },
   "devDependencies": {
-    "async": "^1.5.2",
-    "coveralls": "^2.11.9",
-    "exif-reader": "^1.0.0",
+    "async": "^2.1.0",
+    "bufferutil": "^1.2.1",
+    "coveralls": "^2.11.14",
+    "exif-reader": "^1.0.1",
     "icc": "^0.0.2",
-    "istanbul": "^0.4.2",
-    "mocha": "^2.4.5",
+    "istanbul": "^0.4.5",
+    "mocha": "^3.1.2",
     "mocha-jshint": "^2.3.1",
     "node-cpplint": "^0.4.0",
-    "rimraf": "^2.5.2",
-    "bufferutil": "^1.2.1"
+    "rimraf": "^2.5.4",
+    "unzip": "^0.1.11"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.2.3"
+    "libvips": "8.3.3"
   },
   "engines": {
     "node": ">=0.10"

packaging/README.md

@@ -0,0 +1,57 @@
+# Packaging scripts
+
+libvips and its dependencies are provided as pre-compiled shared libraries
+for the most common operating systems and CPU architectures.
+
+During `npm install`, these binaries are fetched as tarballs from
+[Bintray](https://dl.bintray.com/lovell/sharp/) via HTTPS
+and stored locally within `node_modules/sharp`.
+
+## Using a custom tarball
+
+A custom tarball stored on the local filesystem can be used instead.
+Place it in the following location, where `x.y.z` is the libvips version,
+`platform` is the value of `process.platform` and
+`arch` is the value of `process.arch` (plus the version number for ARM).
+
+`node_modules/sharp/packaging/libvips-x.y.z-platform-arch.tar.gz`
+
+For example, for libvips v8.3.3 on an ARMv6 Linux machine, use:
+
+`node_modules/sharp/packaging/libvips-8.3.3-linux-armv6.tar.gz`
+
+Remove any `sharp/lib` and `sharp/include` directories
+before running `npm install` again.
+
+## Creating a tarball
+
+Most people will not need to do this; proceed with caution.
+
+The `packaging` directory contains the top-level [build script](build.sh).
+
+### Linux
+
+One [build script](build/lin.sh) is used to (cross-)compile
+the same shared libraries within multiple containers.
+
+* [x64](linux-x64/Dockerfile)
+* [ARMv6](linux-armv6/Dockerfile)
+* [ARMv7-A](linux-armv7/Dockerfile)
+* [ARMv8-A](linux-armv8/Dockerfile)
+
+The QEMU user mode emulation binaries are required to build for
+the ARMv6 platform as the Debian armhf cross-compiler erroneously
+generates unsupported Thumb 2 instructions.
+
+```sh
+sudo apt-get install qemu-user-static
+```
+
+### Windows
+
+The output of libvips' [build-win64](https://github.com/jcupitt/build-win64)
+"web" target is [post-processed](build/win.sh) within a [container](win32-x64/Dockerfile).
+
+### OS X
+
+See [package-libvips-darwin](https://github.com/lovell/package-libvips-darwin).

packaging/arm-build.sh

@@ -1,34 +0,0 @@
-#!/bin/sh
-
-if [ $# -lt 1 ]; then
-  echo "Usage: $0 IP"
-  echo "Build libvips for ARM using Docker, where IP is"
-  echo "the address of a Raspberry Pi running HypriotOS"
-  exit 1
-fi
-IP="$1"
-
-echo "Verifying connectivity to $IP"
-if ! ping -c 1 $IP; then
-  echo "Could not connect to $IP"
-  exit 1
-fi
-
-if ! type sshpass >/dev/null; then
-  echo "Please install sshpass"
-  exit 1
-fi
-
-export SSHPASS=hypriot
-
-echo "Copying arm/Dockerfile and arm/build.sh to device"
-sshpass -e scp -o PreferredAuthentications=password -r arm root@${IP}:/root
-
-echo "Building Raspbian-based container"
-sshpass -e ssh -o PreferredAuthentications=password -t root@${IP} "docker build -t vips-dev-arm arm"
-
-echo "Running arm/build.sh within container"
-sshpass -e ssh -o PreferredAuthentications=password -t root@${IP} "docker run -i -t --rm -v \${PWD}/arm:/arm vips-dev-arm sh -c 'cd /arm && ./build.sh' | tee arm/build.log"
-
-echo "Copying resultant tar.gz file from device"
-sshpass -e scp -o PreferredAuthentications=password root@${IP}:/root/arm/*.tar.gz .

packaging/arm/Dockerfile

@@ -1,5 +0,0 @@
-FROM resin/rpi-raspbian:jessie
-MAINTAINER Lovell Fuller <npm@lovell.info>
-
-# Build dependencies
-RUN apt-get update && apt-get install -y build-essential autoconf libtool nasm gtk-doc-tools texinfo curl

packaging/arm/build.sh

@@ -1,137 +0,0 @@
-#!/bin/sh
-
-# To be run inside a Raspbian container
-
-# Working directories
-DEPS=/deps
-TARGET=/target
-mkdir ${DEPS}
-mkdir ${TARGET}
-
-# Common build paths and flags
-export PKG_CONFIG_PATH="${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig"
-export PATH="${PATH}:${TARGET}/bin"
-export CPPFLAGS="-I${TARGET}/include"
-export LDFLAGS="-L${TARGET}/lib"
-export CFLAGS="-O3"
-export CXXFLAGS="-O3"
-
-# Dependency version numbers
-VERSION_ZLIB=1.2.8
-VERSION_FFI=3.2.1
-VERSION_GLIB=2.47.6
-VERSION_XML2=2.9.3
-VERSION_GSF=1.14.34
-VERSION_EXIF=0.6.21
-VERSION_LCMS2=2.7
-VERSION_GM=1.3.23
-VERSION_JPEG=1.4.2
-VERSION_PNG16=1.6.21
-VERSION_WEBP=0.5.0
-VERSION_TIFF=4.0.6
-VERSION_ORC=0.4.25
-VERSION_VIPS=8.2.3
-
-mkdir ${DEPS}/zlib
-curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
-cd ${DEPS}/zlib
-./configure --prefix=${TARGET} && make install
-rm ${TARGET}/lib/libz.a
-
-mkdir ${DEPS}/ffi
-curl -Ls ftp://sourceware.org/pub/libffi/libffi-${VERSION_FFI}.tar.gz | tar xzC ${DEPS}/ffi --strip-components=1
-cd ${DEPS}/ffi
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir && make install-strip
-
-mkdir ${DEPS}/glib
-curl -Ls https://download.gnome.org/sources/glib/2.47/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
-cd ${DEPS}/glib
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-pcre=internal && make install-strip
-
-mkdir ${DEPS}/xml2
-curl -Ls http://xmlsoft.org/sources/libxml2-${VERSION_XML2}.tar.gz | tar xzC ${DEPS}/xml2 --strip-components=1
-cd ${DEPS}/xml2
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-python --with-zlib=${TARGET} && make install-strip
-
-mkdir ${DEPS}/gsf
-curl -Ls https://download.gnome.org/sources/libgsf/1.14/libgsf-${VERSION_GSF}.tar.xz | tar xJC ${DEPS}/gsf --strip-components=1
-cd ${DEPS}/gsf
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/exif
-curl -Ls http://heanet.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
-cd ${DEPS}/exif
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/lcms2
-curl -Ls http://heanet.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
-cd ${DEPS}/lcms2
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/gm
-curl -Ls http://heanet.dl.sourceforge.net/project/graphicsmagick/graphicsmagick/${VERSION_GM}/GraphicsMagick-${VERSION_GM}.tar.xz | tar xJC ${DEPS}/gm --strip-components=1
-cd ${DEPS}/gm
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-magick-plus-plus && make install-strip
-
-mkdir ${DEPS}/jpeg
-curl -Ls http://heanet.dl.sourceforge.net/project/libjpeg-turbo/${VERSION_JPEG}/libjpeg-turbo-${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
-cd ${DEPS}/jpeg
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
-
-mkdir ${DEPS}/png16
-curl -Ls http://heanet.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
-cd ${DEPS}/png16
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/webp
-curl -Ls http://downloads.webmproject.org/releases/webp/libwebp-${VERSION_WEBP}.tar.gz | tar xzC ${DEPS}/webp --strip-components=1
-cd ${DEPS}/webp
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/tiff
-curl -Ls http://download.osgeo.org/libtiff/tiff-${VERSION_TIFF}.tar.gz | tar xzC ${DEPS}/tiff --strip-components=1
-cd ${DEPS}/tiff
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-rm ${TARGET}/lib/libtiffxx*
-
-mkdir ${DEPS}/orc
-curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz | tar xJC ${DEPS}/orc --strip-components=1
-cd ${DEPS}/orc
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-mkdir ${DEPS}/vips
-curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.2/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
-cd ${DEPS}/vips
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
-  --disable-debug --disable-introspection --without-python --without-fftw --with-magickpackage=GraphicsMagick \
-  --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
-  --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib \
-  && make install-strip
-
-# Remove the old C++ bindings
-cd ${TARGET}/include
-rm -rf vips/vipsc++.h vips/vipscpp.h
-cd ${TARGET}/lib
-rm -rf pkgconfig .libs *.la libvipsCC*
-
-# Create JSON file of version numbers
-cd ${TARGET}
-echo "{\n\
-  \"exif\": \"${VERSION_EXIF}\",\n\
-  \"ffi\": \"${VERSION_FFI}\",\n\
-  \"glib\": \"${VERSION_GLIB}\",\n\
-  \"gsf\": \"${VERSION_GSF}\",\n\
-  \"jpeg\": \"${VERSION_JPEG}\",\n\
-  \"lcms\": \"${VERSION_LCMS2}\",\n\
-  \"gm\": \"${VERSION_GM}\",\n\
-  \"orc\": \"${VERSION_ORC}\",\n\
-  \"png\": \"${VERSION_PNG16}\",\n\
-  \"tiff\": \"${VERSION_TIFF}\",\n\
-  \"vips\": \"${VERSION_VIPS}\"\n\
-  \"webp\": \"${VERSION_WEBP}\",\n\
-  \"xml\": \"${VERSION_XML2}\",\n\
-  \"zlib\": \"${VERSION_ZLIB}\",\n\
-}" >lib/versions.json
-
-# Create .tar.gz
-GZIP=-9 tar czf /arm/libvips-${VERSION_VIPS}-arm.tar.gz include lib

packaging/build.sh

@@ -1,30 +1,43 @@
 #!/bin/sh
+set -e
 
-VERSION_VIPS=8.2.3
+if [ $# -lt 1 ]; then
+  echo
+  echo "Usage: $0 VERSION [PLATFORM]"
+  echo "Build shared libraries for libvips and its dependencies via containers"
+  echo
+  echo "Please specify the libvips VERSION, e.g. 8.3.3"
+  echo
+  echo "Optionally build for only one PLATFORM, defaults to building for all"
+  echo "Possible values for PLATFORM are: win32-x64, linux-x64, linux-armv6,"
+  echo "linux-armv7, linux-armv8"
+  echo
+  exit 1
+fi
+VERSION_VIPS="$1"
+PLATFORM="${2:-all}"
 
 # Is docker available?
-
 if ! type docker >/dev/null; then
   echo "Please install docker"
   exit 1
 fi
 
-# TODO: docker v1.9.0 will allow build-time args - https://github.com/docker/docker/pull/15182
+# Windows (x64)
+if [ $PLATFORM = "all" ] || [ $PLATFORM = "win32-x64" ]; then
+  echo "Building win32-x64..."
+  docker build -t vips-dev-win32-x64 win32-x64
+  docker run --rm -e "VERSION_VIPS=${VERSION_VIPS}" -v $PWD:/packaging vips-dev-win32-x64 sh -c "/packaging/build/win.sh"
+fi
 
-# Windows
-
-docker build -t vips-dev-win win
-WIN_CONTAINER_ID=$(docker run -d vips-dev-win)
-docker cp "${WIN_CONTAINER_ID}:/libvips-${VERSION_VIPS}-win.tar.gz" .
-docker rm "${WIN_CONTAINER_ID}"
-
-# Linux
-
-docker build -t vips-dev-lin lin
-LIN_CONTAINER_ID=$(docker run -d vips-dev-lin)
-docker cp "${LIN_CONTAINER_ID}:/libvips-${VERSION_VIPS}-lin.tar.gz" .
-docker rm "${LIN_CONTAINER_ID}"
-
-# Checksums
+# Linux (x64, ARMv6, ARMv7, ARMv8)
+for flavour in linux-x64 linux-armv6 linux-armv7 linux-armv8; do
+  if [ $PLATFORM = "all" ] || [ $PLATFORM = $flavour ]; then
+    echo "Building $flavour..."
+    docker build -t vips-dev-$flavour $flavour
+    docker run --rm -e "VERSION_VIPS=${VERSION_VIPS}" -v $PWD:/packaging vips-dev-$flavour sh -c "/packaging/build/lin.sh"
+  fi
+done
 
+# Display checksums
 sha256sum *.tar.gz

packaging/build/lin.sh

@@ -0,0 +1,236 @@
+#!/bin/sh
+set -e
+
+# Working directories
+DEPS=/deps
+TARGET=/target
+mkdir ${DEPS}
+mkdir ${TARGET}
+
+# Common build paths and flags
+export PKG_CONFIG_PATH="${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig"
+export PATH="${PATH}:${TARGET}/bin"
+export CPPFLAGS="-I${TARGET}/include"
+export LDFLAGS="-L${TARGET}/lib"
+export CFLAGS="${FLAGS}"
+export CXXFLAGS="${FLAGS}"
+
+# Dependency version numbers
+VERSION_ZLIB=1.2.8
+VERSION_FFI=3.2.1
+VERSION_GLIB=2.49.4
+VERSION_XML2=2.9.4
+VERSION_GSF=1.14.39
+VERSION_EXIF=0.6.21
+VERSION_LCMS2=2.8
+VERSION_JPEG=1.5.0
+VERSION_PNG16=1.6.25
+VERSION_WEBP=0.5.1
+VERSION_TIFF=4.0.6
+VERSION_ORC=0.4.25
+VERSION_GDKPIXBUF=2.35.2
+VERSION_FREETYPE=2.6.5
+VERSION_FONTCONFIG=2.12.0
+VERSION_HARFBUZZ=1.3.0
+VERSION_PIXMAN=0.34.0
+VERSION_CAIRO=1.14.6
+VERSION_PANGO=1.40.1
+VERSION_CROCO=0.6.11
+VERSION_SVG=2.40.16
+VERSION_GIF=5.1.4
+
+# Least out-of-sync Sourceforge mirror
+SOURCEFORGE_MIRROR=netix
+
+mkdir ${DEPS}/zlib
+curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
+cd ${DEPS}/zlib
+./configure --prefix=${TARGET} --uname=linux
+make install
+rm ${TARGET}/lib/libz.a
+
+mkdir ${DEPS}/ffi
+curl -Ls ftp://sourceware.org/pub/libffi/libffi-${VERSION_FFI}.tar.gz | tar xzC ${DEPS}/ffi --strip-components=1
+cd ${DEPS}/ffi
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir
+make install-strip
+
+mkdir ${DEPS}/glib
+curl -Ls https://download.gnome.org/sources/glib/2.49/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
+cd ${DEPS}/glib
+echo glib_cv_stack_grows=no >>glib.cache
+echo glib_cv_uscore=no >>glib.cache
+./configure --cache-file=glib.cache --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-pcre=internal
+make install-strip
+
+mkdir ${DEPS}/xml2
+curl -Ls http://xmlsoft.org/sources/libxml2-${VERSION_XML2}.tar.gz | tar xzC ${DEPS}/xml2 --strip-components=1
+cd ${DEPS}/xml2
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --without-python --without-debug --without-docbook --without-ftp --without-html --without-legacy \
+  --without-pattern --without-push --without-regexps --without-schemas --without-schematron --with-zlib=${TARGET}
+make install-strip
+
+mkdir ${DEPS}/gsf
+curl -Ls https://download.gnome.org/sources/libgsf/1.14/libgsf-${VERSION_GSF}.tar.xz | tar xJC ${DEPS}/gsf --strip-components=1
+cd ${DEPS}/gsf
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/exif
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
+cd ${DEPS}/exif
+autoreconf -fiv
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/lcms2
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
+cd ${DEPS}/lcms2
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/jpeg
+curl -Ls https://github.com/libjpeg-turbo/libjpeg-turbo/archive/${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
+cd ${DEPS}/jpeg
+autoreconf -fiv
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg
+make install-strip
+
+mkdir ${DEPS}/png16
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
+cd ${DEPS}/png16
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/webp
+curl -Ls http://downloads.webmproject.org/releases/webp/libwebp-${VERSION_WEBP}.tar.gz | tar xzC ${DEPS}/webp --strip-components=1
+cd ${DEPS}/webp
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-neon
+make install-strip
+
+mkdir ${DEPS}/tiff
+curl -Ls http://download.osgeo.org/libtiff/tiff-${VERSION_TIFF}.tar.gz | tar xzC ${DEPS}/tiff --strip-components=1
+cd ${DEPS}/tiff
+if [ -n "${CHOST}" ]; then autoreconf -fiv; fi
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-mdi --disable-cxx
+make install-strip
+
+mkdir ${DEPS}/orc
+curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz | tar xJC ${DEPS}/orc --strip-components=1
+cd ${DEPS}/orc
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+cd ${TARGET}/lib
+rm -rf liborc-test-*
+
+mkdir ${DEPS}/gdkpixbuf
+curl -Ls https://download.gnome.org/sources/gdk-pixbuf/2.35/gdk-pixbuf-${VERSION_GDKPIXBUF}.tar.xz | tar xJC ${DEPS}/gdkpixbuf --strip-components=1
+cd ${DEPS}/gdkpixbuf
+LD_LIBRARY_PATH=${TARGET}/lib \
+./configure --cache-file=gdkpixbuf.cache --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-introspection --disable-modules --disable-gio-sniffing --without-libpng --without-libjpeg --without-libtiff --without-gdiplus --with-included-loaders=
+make install-strip
+
+mkdir ${DEPS}/freetype
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/freetype/freetype2/${VERSION_FREETYPE}/freetype-${VERSION_FREETYPE}.tar.gz | tar xzC ${DEPS}/freetype --strip-components=1
+cd ${DEPS}/freetype
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static
+make install
+
+mkdir ${DEPS}/fontconfig
+curl -Ls https://www.freedesktop.org/software/fontconfig/release/fontconfig-${VERSION_FONTCONFIG}.tar.bz2 | tar xjC ${DEPS}/fontconfig --strip-components=1
+cd ${DEPS}/fontconfig
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --enable-libxml2
+make install-strip
+
+mkdir ${DEPS}/harfbuzz
+curl -Ls https://www.freedesktop.org/software/harfbuzz/release/harfbuzz-${VERSION_HARFBUZZ}.tar.bz2 | tar xjC ${DEPS}/harfbuzz --strip-components=1
+cd ${DEPS}/harfbuzz
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/pixman
+curl -Ls http://cairographics.org/releases/pixman-${VERSION_PIXMAN}.tar.gz | tar xzC ${DEPS}/pixman --strip-components=1
+cd ${DEPS}/pixman
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-libpng --disable-arm-iwmmxt
+make install-strip
+
+mkdir ${DEPS}/cairo
+curl -Ls http://cairographics.org/releases/cairo-${VERSION_CAIRO}.tar.xz | tar xJC ${DEPS}/cairo --strip-components=1
+cd ${DEPS}/cairo
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-xlib --disable-xcb --disable-quartz --disable-win32 --disable-egl --disable-glx --disable-wgl \
+  --disable-script --disable-ps --disable-gobject --disable-trace --disable-interpreter
+make install-strip
+
+mkdir ${DEPS}/pango
+curl -Ls https://download.gnome.org/sources/pango/1.40/pango-${VERSION_PANGO}.tar.xz | tar xJC ${DEPS}/pango --strip-components=1
+cd ${DEPS}/pango
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/croco
+curl -Ls https://download.gnome.org/sources/libcroco/0.6/libcroco-${VERSION_CROCO}.tar.xz | tar xJC ${DEPS}/croco --strip-components=1
+cd ${DEPS}/croco
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/svg
+curl -Ls https://download.gnome.org/sources/librsvg/2.40/librsvg-${VERSION_SVG}.tar.xz | tar xJC ${DEPS}/svg --strip-components=1
+cd ${DEPS}/svg
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-introspection --disable-tools --disable-pixbuf-loader
+make install-strip
+
+mkdir ${DEPS}/gif
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/giflib/giflib-${VERSION_GIF}.tar.gz | tar xzC ${DEPS}/gif --strip-components=1
+cd ${DEPS}/gif
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking
+make install-strip
+
+mkdir ${DEPS}/vips
+curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.3/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
+cd ${DEPS}/vips
+./configure --host=${CHOST} --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-debug --disable-introspection --without-python --without-fftw \
+  --without-magick --without-pangoft2 --without-ppm --without-analyze --without-radiance \
+  --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
+  --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib
+make install-strip
+
+# Remove the old C++ bindings
+cd ${TARGET}/include
+rm -rf vips/vipsc++.h vips/vipscpp.h
+cd ${TARGET}/lib
+rm -rf pkgconfig .libs *.la libvipsCC*
+
+# Create JSON file of version numbers
+cd ${TARGET}
+echo "{\n\
+  \"cairo\": \"${VERSION_CAIRO}\",\n\
+  \"croco\": \"${VERSION_CROCO}\",\n\
+  \"exif\": \"${VERSION_EXIF}\",\n\
+  \"ffi\": \"${VERSION_FFI}\",\n\
+  \"fontconfig\": \"${VERSION_FONTCONFIG}\",\n\
+  \"freetype\": \"${VERSION_FREETYPE}\",\n\
+  \"gdkpixbuf\": \"${VERSION_GDKPIXBUF}\",\n\
+  \"gif\": \"${VERSION_GIF}\",\n\
+  \"glib\": \"${VERSION_GLIB}\",\n\
+  \"gsf\": \"${VERSION_GSF}\",\n\
+  \"harfbuzz\": \"${VERSION_HARFBUZZ}\",\n\
+  \"jpeg\": \"${VERSION_JPEG}\",\n\
+  \"lcms\": \"${VERSION_LCMS2}\",\n\
+  \"orc\": \"${VERSION_ORC}\",\n\
+  \"pango\": \"${VERSION_PANGO}\",\n\
+  \"pixman\": \"${VERSION_PIXMAN}\",\n\
+  \"png\": \"${VERSION_PNG16}\",\n\
+  \"svg\": \"${VERSION_SVG}\",\n\
+  \"tiff\": \"${VERSION_TIFF}\",\n\
+  \"vips\": \"${VERSION_VIPS}\",\n\
+  \"webp\": \"${VERSION_WEBP}\",\n\
+  \"xml\": \"${VERSION_XML2}\",\n\
+  \"zlib\": \"${VERSION_ZLIB}\"\n\
+}" >lib/versions.json
+
+# Create .tar.gz
+tar czf /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz include lib
+advdef --recompress --shrink-insane /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz

packaging/build/win.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+set -e
+
+# Fetch and unzip
+mkdir /vips
+cd /vips
+curl -L -O https://github.com/lovell/build-win64/releases/download/v${VERSION_VIPS}/vips-dev-w64-web-${VERSION_VIPS}.zip
+unzip vips-dev-w64-web-${VERSION_VIPS}.zip
+
+# Clean and zip
+cd /vips/vips-dev-8.3
+rm bin/libvipsCC-42.dll bin/libvips-cpp-42.dll bin/libgsf-win32-1-114.dll
+cp bin/*.dll lib/
+cp -r lib64/* lib/
+
+echo "Creating tarball"
+tar czf /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz include lib/glib-2.0 lib/libvips.lib lib/libglib-2.0.lib lib/libgobject-2.0.lib lib/*.dll
+echo "Shrinking tarball"
+advdef --recompress --shrink-insane /packaging/libvips-${VERSION_VIPS}-${PLATFORM}.tar.gz

packaging/lin/Dockerfile

@@ -1,139 +0,0 @@
-FROM debian:wheezy
-MAINTAINER Lovell Fuller <npm@lovell.info>
-
-# Build dependencies
-RUN apt-get update && apt-get install -y build-essential autoconf libtool nasm gtk-doc-tools texinfo
-
-# Create working directories
-ENV DEPS=/deps \
-    TARGET=/target
-RUN mkdir ${DEPS} && mkdir ${TARGET}
-
-# Common build paths and flags
-ENV PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig \
-    PATH=${PATH}:${TARGET}/bin \
-    CPPFLAGS=-I${TARGET}/include \
-    LDFLAGS=-L${TARGET}/lib \
-    CFLAGS="-O3" \
-    CXXFLAGS="-O3"
-
-# Dependency version numbers
-ENV VERSION_ZLIB=1.2.8 \
-    VERSION_FFI=3.2.1 \
-    VERSION_GLIB=2.47.6 \
-    VERSION_XML2=2.9.3 \
-    VERSION_GSF=1.14.34 \
-    VERSION_EXIF=0.6.21 \
-    VERSION_LCMS2=2.7 \
-    VERSION_GM=1.3.23 \
-    VERSION_JPEG=1.4.2 \
-    VERSION_PNG16=1.6.21 \
-    VERSION_WEBP=0.5.0 \
-    VERSION_TIFF=4.0.6 \
-    VERSION_ORC=0.4.25 \
-    VERSION_VIPS=8.2.3
-
-RUN mkdir ${DEPS}/zlib
-RUN curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
-WORKDIR ${DEPS}/zlib
-RUN ./configure --prefix=${TARGET} && make install
-RUN rm ${TARGET}/lib/libz.a
-
-RUN mkdir ${DEPS}/ffi
-RUN curl -Ls ftp://sourceware.org/pub/libffi/libffi-${VERSION_FFI}.tar.gz | tar xzC ${DEPS}/ffi --strip-components=1
-WORKDIR ${DEPS}/ffi
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir && make install-strip
-
-RUN mkdir ${DEPS}/glib
-RUN curl -Ls https://download.gnome.org/sources/glib/2.47/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
-WORKDIR ${DEPS}/glib
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-pcre=internal && make install-strip
-
-RUN mkdir ${DEPS}/xml2
-RUN curl -Ls http://xmlsoft.org/sources/libxml2-${VERSION_XML2}.tar.gz | tar xzC ${DEPS}/xml2 --strip-components=1
-WORKDIR ${DEPS}/xml2
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-python --with-zlib=${TARGET} && make install-strip
-
-RUN mkdir ${DEPS}/gsf
-RUN curl -Ls https://download.gnome.org/sources/libgsf/1.14/libgsf-${VERSION_GSF}.tar.xz | tar xJC ${DEPS}/gsf --strip-components=1
-WORKDIR ${DEPS}/gsf
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/exif
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
-WORKDIR ${DEPS}/exif
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/lcms2
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
-WORKDIR ${DEPS}/lcms2
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/gm
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/graphicsmagick/graphicsmagick/${VERSION_GM}/GraphicsMagick-${VERSION_GM}.tar.xz | tar xJC ${DEPS}/gm --strip-components=1
-WORKDIR ${DEPS}/gm
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-magick-plus-plus && make install-strip
-
-RUN mkdir ${DEPS}/jpeg
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libjpeg-turbo/${VERSION_JPEG}/libjpeg-turbo-${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
-WORKDIR ${DEPS}/jpeg
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
-
-RUN mkdir ${DEPS}/png16
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
-WORKDIR ${DEPS}/png16
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/webp
-RUN curl -Ls http://downloads.webmproject.org/releases/webp/libwebp-${VERSION_WEBP}.tar.gz | tar xzC ${DEPS}/webp --strip-components=1
-WORKDIR ${DEPS}/webp
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/tiff
-RUN curl -Ls http://download.osgeo.org/libtiff/tiff-${VERSION_TIFF}.tar.gz | tar xzC ${DEPS}/tiff --strip-components=1
-WORKDIR ${DEPS}/tiff
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-RUN rm ${TARGET}/lib/libtiffxx*
-
-RUN mkdir ${DEPS}/orc
-RUN curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz | tar xJC ${DEPS}/orc --strip-components=1
-WORKDIR ${DEPS}/orc
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
-
-RUN mkdir ${DEPS}/vips
-RUN curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.2/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
-WORKDIR ${DEPS}/vips
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
-  --disable-debug --disable-introspection --without-python --without-fftw --with-magickpackage=GraphicsMagick \
-  --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
-  --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib \
-  && make install-strip
-
-# Remove the old C++ bindings
-WORKDIR ${TARGET}/include
-RUN rm -rf vips/vipsc++.h vips/vipscpp.h
-WORKDIR ${TARGET}/lib
-RUN rm -rf pkgconfig .libs *.la libvipsCC*
-
-# Create JSON file of version numbers
-WORKDIR ${TARGET}
-RUN echo "{\n\
-  \"exif\": \"${VERSION_EXIF}\",\n\
-  \"ffi\": \"${VERSION_FFI}\",\n\
-  \"glib\": \"${VERSION_GLIB}\",\n\
-  \"gsf\": \"${VERSION_GSF}\",\n\
-  \"jpeg\": \"${VERSION_JPEG}\",\n\
-  \"lcms\": \"${VERSION_LCMS2}\",\n\
-  \"gm\": \"${VERSION_GM}\",\n\
-  \"orc\": \"${VERSION_ORC}\",\n\
-  \"png\": \"${VERSION_PNG16}\",\n\
-  \"tiff\": \"${VERSION_TIFF}\",\n\
-  \"vips\": \"${VERSION_VIPS}\"\n\
-  \"webp\": \"${VERSION_WEBP}\",\n\
-  \"xml\": \"${VERSION_XML2}\",\n\
-  \"zlib\": \"${VERSION_ZLIB}\",\n\
-}" >lib/versions.json
-
-# Create .tar.gz
-WORKDIR ${TARGET}
-RUN GZIP=-9 tar czf /libvips-${VERSION_VIPS}-lin.tar.gz include lib

packaging/linux-armv6/Dockerfile

@@ -0,0 +1,15 @@
+FROM socialdefect/raspbian-jessie-core
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Rasbian-based container suitable for compiling Linux ARMv6 binaries
+# Requires the QEMU user mode emulation binaries on the host machine
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y build-essential curl autoconf libtool nasm gtk-doc-tools texinfo advancecomp libglib2.0-dev
+
+# Compiler settings
+ENV \
+  PLATFORM=linux-armv6 \
+  FLAGS="-Os"

packaging/linux-armv7/Dockerfile

@@ -0,0 +1,20 @@
+FROM debian:jessie
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for cross-compiling Linux ARMv7-A binaries
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y curl && \
+  echo "deb http://emdebian.org/tools/debian/ jessie main" | tee /etc/apt/sources.list.d/crosstools.list && \
+  curl http://emdebian.org/tools/debian/emdebian-toolchain-archive.key | apt-key add - && \
+  dpkg --add-architecture armhf && \
+  apt-get update && \
+  apt-get install -y crossbuild-essential-armhf autoconf libtool nasm gtk-doc-tools texinfo advancecomp libglib2.0-dev
+
+# Compiler settings
+ENV \
+  PLATFORM=linux-armv7 \
+  CHOST=arm-linux-gnueabihf \
+  FLAGS="-marm -march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard -Os"

packaging/linux-armv8/Dockerfile

@@ -0,0 +1,18 @@
+FROM debian:stretch
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for cross-compiling Linux ARMv8-A binaries
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y curl && \
+  dpkg --add-architecture arm64 && \
+  apt-get update && \
+  apt-get install -y crossbuild-essential-arm64 autoconf libtool nasm gtk-doc-tools texinfo advancecomp libglib2.0-dev
+
+# Compiler settings
+ENV \
+  PLATFORM=linux-armv8 \
+  CHOST=aarch64-linux-gnu \
+  FLAGS="-march=armv8-a -Os -D_GLIBCXX_USE_CXX11_ABI=0"

packaging/linux-x64/Dockerfile

@@ -0,0 +1,14 @@
+FROM debian:wheezy
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for building Linux x64 binaries
+
+# Build dependencies
+RUN \
+  apt-get update && \
+  apt-get install -y build-essential autoconf libtool nasm gtk-doc-tools texinfo advancecomp
+
+# Compiler settings
+ENV \
+  PLATFORM="linux-x64" \
+  FLAGS="-O3"

packaging/test-linux-arm.sh

@@ -22,7 +22,7 @@ fi
 export SSHPASS=hypriot
 
 echo "Copying sharp source to device"
-sshpass -e scp -o PreferredAuthentications=password -r ../../sharp root@${IP}:/root/sharp
+sshpass -e scp -o PreferredAuthentications=password -r ../../sharp pirate@${IP}:/home/pirate/sharp
 
 echo "Compile and test within container"
-sshpass -e ssh -o PreferredAuthentications=password -t root@${IP} "docker run -i -t --rm -v \${PWD}/sharp:/s hypriot/rpi-node:5 sh -c 'cd /s && npm install --unsafe-perm && npm test'"
+sshpass -e ssh -o PreferredAuthentications=password -t pirate@${IP} "docker run --rm -v \${PWD}/sharp:/s hypriot/rpi-node:6 sh -c 'cd /s && npm install --unsafe-perm && npm test'"

packaging/test-linux-x64.sh

@@ -6,34 +6,33 @@ if ! type docker >/dev/null; then
   exit 1
 fi
 
+version_node=6.3.0
+
 test="npm run clean; npm install --unsafe-perm; npm test"
 
 # Debian 7, 8
-# Ubuntu 12.04, 14.04
-for dist in wheezy jessie precise trusty; do
+# Ubuntu 14.04
+for dist in wheezy jessie trusty; do
   echo "Testing $dist..."
-  if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/$dist:0.12 >packaging/$dist.log 2>&1 sh -c "cd /v; ./packaging/test/debian.sh; $test";
+  if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/$dist:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; ./packaging/test/debian.sh; $test";
   then echo "$dist OK"
   else echo "$dist fail" && cat packaging/$dist.log
   fi
 done
 
-# Centos 6
-echo "Testing centos6..."
-if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/centos6:0.12 >packaging/centos6.log 2>&1 sh -c "cd /v; source ./packaging/test/centos6.sh; ./preinstall.sh; $test";
-then echo "centos6 OK"
-else echo "centos6 fail" && cat packaging/centos6.log
-fi
-
 # Centos 7
-# Fedora 20, 21
-for dist in centos7 fedora20 fedora21; do
-  echo "Testing $dist..."
-  if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/$dist:0.12 >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
-  then echo "$dist OK"
-  else echo "$dist fail" && cat packaging/$dist.log
-  fi
-done
+echo "Testing centos7..."
+if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/centos7:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
+then echo "centos7 OK"
+else echo "centos7 fail" && cat packaging/$dist.log
+fi
+
+# Fedora 22
+echo "Testing fedora22..."
+if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/fedora22:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
+then echo "fedora22 OK"
+else echo "fedora22 fail" && cat packaging/$dist.log
+fi
 
 # openSUSE 13.2
 echo "Testing opensuse..."
@@ -44,7 +43,7 @@ fi
 
 # Archlinux 2015.06.01
 echo "Testing archlinux..."
-if docker run -i -t --rm -v $PWD:/v base/archlinux:2015.06.01 >packaging/archlinux.log 2>&1 sh -c "cd /v; ./packaging/test/archlinux.sh; $test";
+if docker run -i -t --rm -v $PWD:/v pritunl/archlinux:latest >packaging/archlinux.log 2>&1 sh -c "cd /v; ./packaging/test/archlinux.sh; $test";
 then echo "archlinux OK"
 else echo "archlinux fail" && cat packaging/archlinux.log
 fi

packaging/test/alpine.sh

@@ -3,5 +3,5 @@
 # Install build dependencies
 apk add --update make gcc g++ python nodejs
 
-# Install libvips with build headers and dependencies
-apk add libvips-dev --update --repository https://s3.amazonaws.com/wjordan-apk --allow-untrusted
+# Install libvips from aports/testing
+apk add --update --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing vips-dev

packaging/test/centos6.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-
-# Install C++11 compatible version of g++ on Centos 6
-curl -o /etc/yum.repos.d/devtools-1.1.repo http://people.centos.org/tru/devtools-1.1/devtools-1.1.repo
-yum install -y devtoolset-1.1
-export CC=/opt/centos/devtoolset-1.1/root/usr/bin/gcc
-export CPP=/opt/centos/devtoolset-1.1/root/usr/bin/cpp
-export CXX=/opt/centos/devtoolset-1.1/root/usr/bin/c++

packaging/win/Dockerfile

@@ -1,20 +0,0 @@
-FROM ubuntu:precise
-MAINTAINER Lovell Fuller <npm@lovell.info>
-
-RUN apt-get update && apt-get install -y curl zip
-
-ENV VERSION_VIPS=8.2.3
-
-# Fetch and unzip
-RUN mkdir /vips
-WORKDIR /vips
-RUN curl -O http://www.vips.ecs.soton.ac.uk/supported/8.2/win32/vips-dev-w64-8.2.zip
-RUN unzip vips-dev-w64-8.2.zip
-
-# Clean and zip
-WORKDIR /vips/vips-dev-8.2
-RUN rm bin/libvipsCC-42.dll bin/libvips-cpp-42.dll bin/libgsf-win32-1-114.dll bin/libstdc++-6.dll
-RUN cp bin/*.dll lib/
-RUN cp -r lib64/* lib/
-
-RUN GZIP=-9 tar czf /libvips-${VERSION_VIPS}-win.tar.gz include lib/glib-2.0 lib/libvips.lib lib/libglib-2.0.lib lib/libgobject-2.0.lib lib/*.dll

packaging/win32-x64/Dockerfile

@@ -0,0 +1,8 @@
+FROM debian:jessie
+MAINTAINER Lovell Fuller <npm@lovell.info>
+
+# Create Debian-based container suitable for post-processing Windows x64 binaries
+
+RUN apt-get update && apt-get install -y curl zip advancecomp
+
+ENV PLATFORM=win32-x64

preinstall.sh

@@ -1,27 +1,21 @@
 #!/bin/sh
 
-# This script is no longer required on most
-# 64-bit Linux systems when using sharp v0.12.0+
+# Use of this script is deprecated
 
-# See http://sharp.dimens.io/page/install#linux
+echo
+echo "WARNING: This script will stop working at the end of 2016"
+echo
+echo "WARNING: This script is no longer required on most 64-bit Linux systems when using sharp v0.12.0+"
+echo
+echo "See http://sharp.dimens.io/page/install#linux"
+echo
+echo "If you really, really need this script, it will attempt"
+echo "to globally install libvips if not already available."
+echo
+sleep 5
 
-# If you really need this script, it will attempt to
-# globally install libvips if not already available.
-
-# Supports:
-# * Debian Linux
-#   * Debian 7, 8
-#   * Ubuntu 12.04, 14.04, 14.10, 15.04, 15.10
-#   * Mint 13, 17
-#   * Elementary 0.3
-# * Red Hat Linux
-#   * RHEL/Centos/Scientific 6, 7
-#   * Fedora 21, 22, 23
-#   * Amazon Linux 2015.03, 2015.09
-# * OpenSuse 13
-
-vips_version_minimum=8.2.3
-vips_version_latest_major_minor=8.2
+vips_version_minimum=8.3.3
+vips_version_latest_major_minor=8.3
 vips_version_latest_patch=3
 
 openslide_version_minimum=3.4.0
@@ -33,7 +27,7 @@ install_libvips_from_source() {
   curl -O http://www.vips.ecs.soton.ac.uk/supported/$vips_version_latest_major_minor/vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
   tar zvxf vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
   cd vips-$vips_version_latest_major_minor.$vips_version_latest_patch
-  ./configure --disable-debug --disable-docs --disable-static --disable-introspection --disable-dependency-tracking --enable-cxx=yes --without-python --without-orc --without-fftw $1
+  CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=0" ./configure --disable-debug --disable-docs --disable-static --disable-introspection --disable-dependency-tracking --enable-cxx=yes --without-python --without-orc --without-fftw $1
   make
   make install
   cd ..
@@ -139,7 +133,7 @@ if [ $enable_openslide -eq 1 ] && [ -z $vips_with_openslide ] && [ $openslide_ex
     DISTRO=$(lsb_release -c -s)
     echo "Detected Debian Linux '$DISTRO'"
     case "$DISTRO" in
-      jessie|vivid|wily)
+      jessie|vivid|wily|xenial)
         # Debian 8, Ubuntu 15
         echo "Installing libopenslide via apt-get"
         apt-get install -y libopenslide-dev

src/common.cc

@@ -1,32 +1,53 @@
 #include <cstdlib>
 #include <string>
 #include <string.h>
+
+#include <node.h>
+#include <node_buffer.h>
 #include <vips/vips8>
 
+#include "nan.h"
 #include "common.h"
 
-// Verify platform and compiler compatibility
-
-#if (VIPS_MAJOR_VERSION < 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 2))
-#error libvips version 8.2.0+ required - see sharp.dimens.io/page/install
-#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 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 sharp.dimens.io/page/install#prerequisites
-#endif
-#endif
-
-#define EXIF_IFD0_ORIENTATION "exif-ifd0-Orientation"
-
 using vips::VImage;
 
 namespace sharp {
 
+  // Convenience methods to access the attributes of a v8::Object
+  bool HasAttr(v8::Handle<v8::Object> obj, std::string attr) {
+    return Nan::Has(obj, Nan::New(attr).ToLocalChecked()).FromJust();
+  }
+  std::string AttrAsStr(v8::Handle<v8::Object> obj, std::string attr) {
+    return *Nan::Utf8String(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked());
+  }
+
+  // Create an InputDescriptor instance from a v8::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(
+    v8::Handle<v8::Object> input, std::vector<v8::Local<v8::Object>> buffersToPersist
+  ) {
+    Nan::HandleScope();
+    InputDescriptor *descriptor = new InputDescriptor;
+    if (HasAttr(input, "file")) {
+      descriptor->file = AttrAsStr(input, "file");
+    } else {
+      v8::Local<v8::Object> buffer = AttrAs<v8::Object>(input, "buffer");
+      descriptor->bufferLength = node::Buffer::Length(buffer);
+      descriptor->buffer = node::Buffer::Data(buffer);
+      buffersToPersist.push_back(buffer);
+    }
+    // Density for vector-based input
+    if (HasAttr(input, "density")) {
+      descriptor->density = AttrTo<uint32_t>(input, "density");
+    }
+    // Raw pixel input
+    if (HasAttr(input, "rawChannels")) {
+      descriptor->rawChannels = AttrTo<uint32_t>(input, "rawChannels");
+      descriptor->rawWidth = AttrTo<uint32_t>(input, "rawWidth");
+      descriptor->rawHeight = AttrTo<uint32_t>(input, "rawHeight");
+    }
+    return descriptor;
+  }
+
   // How many tasks are in the queue?
   volatile int counterQueue = 0;
 
@@ -52,6 +73,12 @@ namespace sharp {
   bool IsDz(std::string const &str) {
     return EndsWith(str, ".dzi") || EndsWith(str, ".DZI");
   }
+  bool IsDzZip(std::string const &str) {
+    return EndsWith(str, ".zip") || EndsWith(str, ".ZIP") || EndsWith(str, ".szi") || EndsWith(str, ".SZI");
+  }
+  bool IsV(std::string const &str) {
+    return EndsWith(str, ".v") || EndsWith(str, ".V") || EndsWith(str, ".vips") || EndsWith(str, ".VIPS");
+  }
 
   /*
     Provide a string identifier for the given image type.
@@ -63,10 +90,14 @@ namespace sharp {
       case ImageType::PNG: id = "png"; break;
       case ImageType::WEBP: id = "webp"; break;
       case ImageType::TIFF: id = "tiff"; break;
+      case ImageType::GIF: id = "gif"; break;
+      case ImageType::SVG: id = "svg"; break;
+      case ImageType::PDF: id = "pdf"; break;
       case ImageType::MAGICK: id = "magick"; break;
       case ImageType::OPENSLIDE: id = "openslide"; break;
       case ImageType::PPM: id = "ppm"; break;
       case ImageType::FITS: id = "fits"; break;
+      case ImageType::VIPS: id = "v"; break;
       case ImageType::RAW: id = "raw"; break;
       case ImageType::UNKNOWN: id = "unknown"; break;
     }
@@ -89,6 +120,12 @@ namespace sharp {
         imageType = ImageType::WEBP;
       } else if (EndsWith(loader, "TiffBuffer")) {
         imageType = ImageType::TIFF;
+      } else if (EndsWith(loader, "GifBuffer")) {
+        imageType = ImageType::GIF;
+      } else if (EndsWith(loader, "SvgBuffer")) {
+        imageType = ImageType::SVG;
+      } else if (EndsWith(loader, "PdfBuffer")) {
+        imageType = ImageType::PDF;
       } else if (EndsWith(loader, "MagickBuffer")) {
         imageType = ImageType::MAGICK;
       }
@@ -114,10 +151,18 @@ namespace sharp {
         imageType = ImageType::OPENSLIDE;
       } else if (EndsWith(loader, "TiffFile")) {
         imageType = ImageType::TIFF;
+      } else if (EndsWith(loader, "GifFile")) {
+        imageType = ImageType::GIF;
+      } else if (EndsWith(loader, "SvgFile")) {
+        imageType = ImageType::SVG;
+      } else if (EndsWith(loader, "PdfFile")) {
+        imageType = ImageType::PDF;
       } else if (EndsWith(loader, "Ppm")) {
         imageType = ImageType::PPM;
       } else if (EndsWith(loader, "Fits")) {
         imageType = ImageType::FITS;
+      } else if (EndsWith(loader, "Vips")) {
+        imageType = ImageType::VIPS;
       } else if (EndsWith(loader, "Magick") || EndsWith(loader, "MagickFile")) {
         imageType = ImageType::MAGICK;
       }
@@ -125,6 +170,73 @@ namespace sharp {
     return imageType;
   }
 
+  /*
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
+  */
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor, VipsAccess accessMethod) {
+    VImage image;
+    ImageType imageType;
+    if (descriptor->buffer != nullptr) {
+      // From buffer
+      if (descriptor->rawChannels > 0) {
+        // Raw, uncompressed pixel data
+        image = VImage::new_from_memory(descriptor->buffer, descriptor->bufferLength,
+          descriptor->rawWidth, descriptor->rawHeight, descriptor->rawChannels, VIPS_FORMAT_UCHAR);
+        if (descriptor->rawChannels < 3) {
+          image.get_image()->Type = VIPS_INTERPRETATION_B_W;
+        } else {
+          image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
+        }
+        imageType = ImageType::RAW;
+      } else {
+        // Compressed data
+        imageType = DetermineImageType(descriptor->buffer, descriptor->bufferLength);
+        if (imageType != ImageType::UNKNOWN) {
+          try {
+            vips::VOption *option = VImage::option()->set("access", accessMethod);
+            if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
+              option->set("dpi", static_cast<double>(descriptor->density));
+            }
+            if (imageType == ImageType::MAGICK) {
+              option->set("density", std::to_string(descriptor->density).data());
+            }
+            image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
+            if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
+              SetDensity(image, descriptor->density);
+            }
+          } catch (...) {
+            throw vips::VError("Input buffer has corrupt header");
+          }
+        } else {
+          throw vips::VError("Input buffer contains unsupported image format");
+        }
+      }
+    } else {
+      // From filesystem
+      imageType = DetermineImageType(descriptor->file.data());
+      if (imageType != ImageType::UNKNOWN) {
+        try {
+          vips::VOption *option = VImage::option()->set("access", accessMethod);
+          if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
+            option->set("dpi", static_cast<double>(descriptor->density));
+          }
+          if (imageType == ImageType::MAGICK) {
+            option->set("density", std::to_string(descriptor->density).data());
+          }
+          image = VImage::new_from_file(descriptor->file.data(), option);
+          if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
+            SetDensity(image, descriptor->density);
+          }
+        } catch (...) {
+          throw vips::VError("Input file has corrupt header");
+        }
+      } else {
+        throw vips::VError("Input file is missing or of an unsupported image format");
+      }
+    }
+    return std::make_tuple(image, imageType);
+  }
+
   /*
     Does this image have an embedded profile?
   */
@@ -259,4 +371,72 @@ namespace sharp {
     return std::make_tuple(left, top);
   }
 
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y) {
+
+    // default values
+    int left = 0;
+    int top = 0;
+
+    // assign only if valid
+    if(x >= 0 && x < (inWidth - outWidth)) {
+      left = x;
+    } else if(x >= (inWidth - outWidth)) {
+      left = inWidth - outWidth;
+    }
+
+    if(y >= 0 && y < (inHeight - outHeight)) {
+      top = y;
+    } else if(y >= (inHeight - outHeight)) {
+      top = inHeight - outHeight;
+    }
+
+    // the resulting left and top could have been outside the image after calculation from bottom/right edges
+    if(left < 0) {
+      left = 0;
+    }
+    if(top < 0) {
+      top = 0;
+    }
+
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation) {
+    return interpretation == VIPS_INTERPRETATION_RGB16 || interpretation == VIPS_INTERPRETATION_GREY16;
+  }
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation) {
+    return Is16Bit(interpretation) ? 65535.0 : 255.0;
+  }
+
+  /*
+    Get boolean operation type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string const opStr) {
+    return static_cast<VipsOperationBoolean>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_OPERATION_BOOLEAN, opStr.data())
+    );
+  }
+
+  /*
+    Get interpretation type from string
+  */
+  VipsInterpretation GetInterpretation(std::string const typeStr) {
+    return static_cast<VipsInterpretation>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_INTERPRETATION, typeStr.data())
+    );
+  }
+
 }  // namespace sharp

src/common.h

@@ -4,23 +4,85 @@
 #include <string>
 #include <tuple>
 
+#include <node.h>
 #include <vips/vips8>
 
+#include "nan.h"
+
+// Verify platform and compiler compatibility
+
+#if (VIPS_MAJOR_VERSION < 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 3))
+#error libvips version 8.3.x required - see sharp.dimens.io/page/install
+#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 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 sharp.dimens.io/page/install#prerequisites
+#endif
+#endif
+
+#define EXIF_IFD0_ORIENTATION "exif-ifd0-Orientation"
+
 using vips::VImage;
 
 namespace sharp {
 
+  struct InputDescriptor {
+    std::string name;
+    std::string file;
+    char *buffer;
+    size_t bufferLength;
+    int density;
+    int rawChannels;
+    int rawWidth;
+    int rawHeight;
+
+    InputDescriptor():
+      buffer(nullptr),
+      bufferLength(0),
+      density(72),
+      rawChannels(0),
+      rawWidth(0),
+      rawHeight(0) {}
+  };
+
+  // Convenience methods to access the attributes of a v8::Object
+  bool HasAttr(v8::Handle<v8::Object> obj, std::string attr);
+  std::string AttrAsStr(v8::Handle<v8::Object> obj, std::string attr);
+  template<typename T> v8::Local<T> AttrAs(v8::Handle<v8::Object> obj, std::string attr) {
+    return Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked().As<T>();
+  }
+  template<typename T> T AttrTo(v8::Handle<v8::Object> obj, std::string attr) {
+    return Nan::To<T>(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked()).FromJust();
+  }
+  template<typename T> T AttrTo(v8::Handle<v8::Object> obj, int attr) {
+    return Nan::To<T>(Nan::Get(obj, attr).ToLocalChecked()).FromJust();
+  }
+
+  // Create an InputDescriptor instance from a v8::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(
+    v8::Handle<v8::Object> input, std::vector<v8::Local<v8::Object>> buffersToPersist
+  );
+
   enum class ImageType {
-    UNKNOWN,
     JPEG,
     PNG,
     WEBP,
     TIFF,
+    GIF,
+    SVG,
+    PDF,
     MAGICK,
     OPENSLIDE,
     PPM,
     FITS,
-    RAW
+    VIPS,
+    RAW,
+    UNKNOWN
   };
 
   // How many tasks are in the queue?
@@ -35,6 +97,8 @@ namespace sharp {
   bool IsWebp(std::string const &str);
   bool IsTiff(std::string const &str);
   bool IsDz(std::string const &str);
+  bool IsDzZip(std::string const &str);
+  bool IsV(std::string const &str);
 
   /*
     Provide a string identifier for the given image type.
@@ -51,6 +115,11 @@ namespace sharp {
   */
   ImageType DetermineImageType(char const *file);
 
+  /*
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
+  */
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor, VipsAccess accessMethod);
+
   /*
     Does this image have an embedded profile?
   */
@@ -104,6 +173,34 @@ namespace sharp {
   std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
     int const outWidth, int const outHeight, int const gravity);
 
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets of the output image.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y);
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation);
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation);
+
+  /*
+    Get boolean operation type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string const opStr);
+
+  /*
+    Get interpretation type from string
+  */
+  VipsInterpretation GetInterpretation(std::string const typeStr);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_

src/libvips/cplusplus/VImage.cpp

@@ -711,4 +711,499 @@ VImage::maxpos( VOption *options )
 	return( std::complex<double>( x, y ) ); 
 }
 
+// Operator overloads
+
+VImage 
+VImage::operator[]( int index ) 
+{
+	return( this->extract_band( index ) ); 
+}
+
+std::vector<double> 
+VImage::operator()( int x, int y )
+{
+	return( this->getpoint( x, y ) ); 
+}
+
+VImage 
+operator+( VImage a, VImage b ) 
+{
+	return( a.add( b ) );
+}
+
+VImage 
+operator+( double a, VImage b ) 
+{
+	return( b.linear( 1.0, a ) ); 
+}
+
+VImage 
+operator+( VImage a, double b ) 
+{ 
+	return( a.linear( 1.0, b ) ); 
+}
+
+VImage 
+operator+( std::vector<double> a, VImage b ) 
+{
+	return( b.linear( 1.0, a ) ); 
+}
+
+VImage 
+operator+( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( 1.0, b ) ); 
+}
+
+VImage 
+operator-( VImage a, VImage b ) 
+{
+	return( a.subtract( b ) );
+}
+
+VImage operator-( double a, VImage b ) 
+{
+	return( b.linear( -1.0, a ) ); 
+}
+
+VImage 
+operator-( VImage a, double b ) 
+{ 
+	return( a.linear( 1.0, -b ) ); 
+}
+
+VImage 
+operator-( std::vector<double> a, VImage b ) 
+{
+	return( b.linear( -1.0, a ) ); 
+}
+
+VImage 
+operator-( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( 1.0, vips::negate( b ) ) ); 
+}
+
+VImage 
+operator-( VImage a ) 
+{ 
+	return( a * -1 );
+}
+
+VImage 
+operator*( VImage a, VImage b ) 
+{
+	return( a.multiply( b ) );
+}
+
+VImage 
+operator*( double a, VImage b ) 
+{
+	return( b.linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator*( VImage a, double b ) 
+{ 
+	return( a.linear( b, 0.0 ) ); 
+}
+
+VImage 
+operator*( std::vector<double> a, VImage b ) 
+{
+	return( b.linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator*( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( b, 0.0 ) ); 
+}
+
+VImage 
+operator/( VImage a, VImage b ) 
+{
+	return( a.divide( b ) );
+}
+
+VImage 
+operator/( double a, VImage b ) 
+{
+	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator/( VImage a, double b ) 
+{ 
+	return( a.linear( 1.0 / b, 0.0 ) ); 
+}
+
+VImage 
+operator/( std::vector<double> a, VImage b ) 
+{
+	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator/( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( vips::invert( b ), 0.0 ) ); 
+}
+
+VImage 
+operator%( VImage a, VImage b ) 
+{
+	return( a.remainder( b ) );
+}
+
+VImage 
+operator%( VImage a, double b ) 
+{ 
+	return( a.remainder_const( to_vector( b ) ) ); 
+}
+
+VImage 
+operator%( VImage a, std::vector<double> b ) 
+{ 
+	return( a.remainder_const( b ) ); 
+}
+
+VImage 
+operator<( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator<( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator<( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator<( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator<( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator<=( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator<=( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator<=( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator<=( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator<=( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator>( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator>( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator>( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator>( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator>( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator>=( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator>=( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator>=( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator>=( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator>=( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator==( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator!=( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator&( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( double a, VImage b ) 
+{
+	return( b.boolean_const( to_vector( a ), 
+		VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( std::vector<double> a, VImage b ) 
+{
+	return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator|( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( double a, VImage b ) 
+{
+	return( b.boolean_const( to_vector( a ), 
+		VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( std::vector<double> a, VImage b ) 
+{
+	return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator^( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( double a, VImage b ) 
+{
+	return( b.boolean_const( to_vector( a ), 
+		VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( std::vector<double> a, VImage b ) 
+{
+	return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator<<( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
+}
+
+VImage 
+operator<<( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_LSHIFT ) ); 
+}
+
+VImage 
+operator<<( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) ); 
+}
+
+VImage 
+operator>>( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
+}
+
+VImage 
+operator>>( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_RSHIFT ) ); 
+}
+
+VImage 
+operator>>( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) ); 
+}
+
 VIPS_NAMESPACE_END

src/libvips/cplusplus/vips-operators.cpp

@@ -1,5 +1,5 @@
 // bodies for vips operations
-// Sat Jan  9 15:05:58 GMT 2016
+// Fri Feb 12 20:03:53 GMT 2016
 // this file is generated automatically, do not edit!
 
 void VImage::system( char * cmd_format , VOption *options )
@@ -1408,6 +1408,78 @@ VImage VImage::vipsload( char * filename , VOption *options )
     return( out );
 }
 
+VImage VImage::pdfload( char * filename , VOption *options )
+{
+    VImage out;
+
+    call( "pdfload" ,
+        (options ? options : VImage::option()) ->
+            set( "filename", filename ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::pdfload_buffer( VipsBlob * buffer , VOption *options )
+{
+    VImage out;
+
+    call( "pdfload_buffer" ,
+        (options ? options : VImage::option()) ->
+            set( "buffer", buffer ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::svgload( char * filename , VOption *options )
+{
+    VImage out;
+
+    call( "svgload" ,
+        (options ? options : VImage::option()) ->
+            set( "filename", filename ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::svgload_buffer( VipsBlob * buffer , VOption *options )
+{
+    VImage out;
+
+    call( "svgload_buffer" ,
+        (options ? options : VImage::option()) ->
+            set( "buffer", buffer ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::gifload( char * filename , VOption *options )
+{
+    VImage out;
+
+    call( "gifload" ,
+        (options ? options : VImage::option()) ->
+            set( "filename", filename ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::gifload_buffer( VipsBlob * buffer , VOption *options )
+{
+    VImage out;
+
+    call( "gifload_buffer" ,
+        (options ? options : VImage::option()) ->
+            set( "buffer", buffer ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
 VImage VImage::pngload( char * filename , VOption *options )
 {
     VImage out;
@@ -1783,11 +1855,37 @@ VImage VImage::shrinkv( int yshrink , VOption *options )
     return( out );
 }
 
-VImage VImage::shrink2( double xshrink , double yshrink , VOption *options )
+VImage VImage::reduceh( double xshrink , VOption *options )
 {
     VImage out;
 
-    call( "shrink2" ,
+    call( "reduceh" ,
+        (options ? options : VImage::option()) ->
+            set( "in", *this ) ->
+            set( "out", &out ) ->
+            set( "xshrink", xshrink ) );
+
+    return( out );
+}
+
+VImage VImage::reducev( double yshrink , VOption *options )
+{
+    VImage out;
+
+    call( "reducev" ,
+        (options ? options : VImage::option()) ->
+            set( "in", *this ) ->
+            set( "out", &out ) ->
+            set( "yshrink", yshrink ) );
+
+    return( out );
+}
+
+VImage VImage::reduce( double xshrink , double yshrink , VOption *options )
+{
+    VImage out;
+
+    call( "reduce" ,
         (options ? options : VImage::option()) ->
             set( "in", *this ) ->
             set( "out", &out ) ->

src/metadata.cc

@@ -1,135 +1,54 @@
+#include <numeric>
+
 #include <node.h>
 #include <vips/vips8>
 
 #include "nan.h"
-
 #include "common.h"
 #include "metadata.h"
 
-using v8::Handle;
-using v8::Local;
-using v8::Value;
-using v8::Object;
-using v8::Number;
-using v8::String;
-using v8::Boolean;
-using v8::Function;
-using v8::Exception;
-
-using Nan::AsyncQueueWorker;
-using Nan::AsyncWorker;
-using Nan::Callback;
-using Nan::HandleScope;
-using Nan::Utf8String;
-using Nan::Has;
-using Nan::Get;
-using Nan::Set;
-using Nan::New;
-using Nan::NewBuffer;
-using Nan::Null;
-using Nan::Error;
-
-using vips::VImage;
-using vips::VError;
-
-using sharp::ImageType;
-using sharp::ImageTypeId;
-using sharp::DetermineImageType;
-using sharp::HasProfile;
-using sharp::HasAlpha;
-using sharp::ExifOrientation;
-using sharp::HasDensity;
-using sharp::GetDensity;
-using sharp::FreeCallback;
-using sharp::counterQueue;
-
-struct MetadataBaton {
-  // Input
-  std::string fileIn;
-  char *bufferIn;
-  size_t bufferInLength;
-  // Output
-  std::string format;
-  int width;
-  int height;
-  std::string space;
-  int channels;
-  int density;
-  bool hasProfile;
-  bool hasAlpha;
-  int orientation;
-  char *exif;
-  size_t exifLength;
-  char *icc;
-  size_t iccLength;
-  std::string err;
-
-  MetadataBaton():
-    bufferInLength(0),
-    density(0),
-    orientation(0),
-    exifLength(0),
-    iccLength(0) {}
-};
-
-class MetadataWorker : public AsyncWorker {
+class MetadataWorker : public Nan::AsyncWorker {
  public:
-  MetadataWorker(Callback *callback, MetadataBaton *baton, const Local<Object> &bufferIn) :
-    AsyncWorker(callback), baton(baton) {
-      if (baton->bufferInLength > 0) {
-        SaveToPersistent("bufferIn", bufferIn);
+  MetadataWorker(
+    Nan::Callback *callback, MetadataBaton *baton,
+    std::vector<v8::Local<v8::Object>> const buffersToPersist
+  ) : Nan::AsyncWorker(callback), baton(baton), buffersToPersist(buffersToPersist) {
+    // Protect Buffer objects from GC, keyed on index
+    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
+      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
+        SaveToPersistent(index, buffer);
+        return index + 1;
       }
-    }
+    );
+  }
   ~MetadataWorker() {}
 
   void Execute() {
     // Decrement queued task counter
-    g_atomic_int_dec_and_test(&counterQueue);
+    g_atomic_int_dec_and_test(&sharp::counterQueue);
 
-    ImageType imageType = ImageType::UNKNOWN;
-    VImage image;
-    if (baton->bufferInLength > 0) {
-      // From buffer
-      imageType = DetermineImageType(baton->bufferIn, baton->bufferInLength);
-      if (imageType != ImageType::UNKNOWN) {
-        try {
-          image = VImage::new_from_buffer(baton->bufferIn, baton->bufferInLength, nullptr);
-        } catch (...) {
-          (baton->err).append("Input buffer has corrupt header");
-          imageType = ImageType::UNKNOWN;
-        }
-      } else {
-        (baton->err).append("Input buffer contains unsupported image format");
-      }
-    } else {
-      // From file
-      imageType = DetermineImageType(baton->fileIn.data());
-      if (imageType != ImageType::UNKNOWN) {
-        try {
-          image = VImage::new_from_file(baton->fileIn.data());
-        } catch (...) {
-          (baton->err).append("Input file has corrupt header");
-          imageType = ImageType::UNKNOWN;
-        }
-      } else {
-        (baton->err).append("Input file is missing or of an unsupported image format");
-      }
+    vips::VImage image;
+    sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
+    try {
+      std::tie(image, imageType) = OpenInput(baton->input, VIPS_ACCESS_SEQUENTIAL);
+    } catch (vips::VError const &err) {
+      (baton->err).append(err.what());
     }
-    if (imageType != ImageType::UNKNOWN) {
+    if (imageType != sharp::ImageType::UNKNOWN) {
       // Image type
-      baton->format = ImageTypeId(imageType);
+      baton->format = sharp::ImageTypeId(imageType);
       // VipsImage attributes
       baton->width = image.width();
       baton->height = image.height();
       baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image.interpretation());
       baton->channels = image.bands();
-      if (HasDensity(image)) {
-        baton->density = GetDensity(image);
+      if (sharp::HasDensity(image)) {
+        baton->density = sharp::GetDensity(image);
       }
-      baton->hasProfile = HasProfile(image);
+      baton->hasProfile = sharp::HasProfile(image);
       // Derived attributes
-      baton->hasAlpha = HasAlpha(image);
-      baton->orientation = ExifOrientation(image);
+      baton->hasAlpha = sharp::HasAlpha(image);
+      baton->orientation = sharp::ExifOrientation(image);
       // EXIF
       if (image.get_typeof(VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
         size_t exifLength;
@@ -147,53 +66,59 @@ class MetadataWorker : public AsyncWorker {
         baton->iccLength = iccLength;
       }
     }
+
     // Clean up
     vips_error_clear();
     vips_thread_shutdown();
   }
 
   void HandleOKCallback () {
-    HandleScope();
+    using Nan::New;
+    using Nan::Set;
+    Nan::HandleScope();
 
-    Local<Value> argv[2] = { Null(), Null() };
+    v8::Local<v8::Value> argv[2] = { Nan::Null(), Nan::Null() };
     if (!baton->err.empty()) {
-      // Error
-      argv[0] = Error(baton->err.data());
+      argv[0] = Nan::Error(baton->err.data());
     } else {
       // Metadata Object
-      Local<Object> info = New<Object>();
-      Set(info, New("format").ToLocalChecked(), New<String>(baton->format).ToLocalChecked());
-      Set(info, New("width").ToLocalChecked(), New<Number>(baton->width));
-      Set(info, New("height").ToLocalChecked(), New<Number>(baton->height));
-      Set(info, New("space").ToLocalChecked(), New<String>(baton->space).ToLocalChecked());
-      Set(info, New("channels").ToLocalChecked(), New<Number>(baton->channels));
+      v8::Local<v8::Object> info = New<v8::Object>();
+      Set(info, New("format").ToLocalChecked(), New<v8::String>(baton->format).ToLocalChecked());
+      Set(info, New("width").ToLocalChecked(), New<v8::Uint32>(baton->width));
+      Set(info, New("height").ToLocalChecked(), New<v8::Uint32>(baton->height));
+      Set(info, New("space").ToLocalChecked(), New<v8::String>(baton->space).ToLocalChecked());
+      Set(info, New("channels").ToLocalChecked(), New<v8::Uint32>(baton->channels));
       if (baton->density > 0) {
-        Set(info, New("density").ToLocalChecked(), New<Number>(baton->density));
+        Set(info, New("density").ToLocalChecked(), New<v8::Uint32>(baton->density));
       }
-      Set(info, New("hasProfile").ToLocalChecked(), New<Boolean>(baton->hasProfile));
-      Set(info, New("hasAlpha").ToLocalChecked(), New<Boolean>(baton->hasAlpha));
+      Set(info, New("hasProfile").ToLocalChecked(), New<v8::Boolean>(baton->hasProfile));
+      Set(info, New("hasAlpha").ToLocalChecked(), New<v8::Boolean>(baton->hasAlpha));
       if (baton->orientation > 0) {
-        Set(info, New("orientation").ToLocalChecked(), New<Number>(baton->orientation));
+        Set(info, New("orientation").ToLocalChecked(), New<v8::Uint32>(baton->orientation));
       }
       if (baton->exifLength > 0) {
         Set(info,
           New("exif").ToLocalChecked(),
-          NewBuffer(baton->exif, baton->exifLength, FreeCallback, nullptr).ToLocalChecked()
+          Nan::NewBuffer(baton->exif, baton->exifLength, sharp::FreeCallback, nullptr).ToLocalChecked()
         );
       }
       if (baton->iccLength > 0) {
         Set(info,
           New("icc").ToLocalChecked(),
-          NewBuffer(baton->icc, baton->iccLength, FreeCallback, nullptr).ToLocalChecked()
+          Nan::NewBuffer(baton->icc, baton->iccLength, sharp::FreeCallback, nullptr).ToLocalChecked()
         );
       }
       argv[1] = info;
     }
 
-    // Dispose of Persistent wrapper around input Buffer so it can be garbage collected
-    if (baton->bufferInLength > 0) {
-      GetFromPersistent("bufferIn");
-    }
+    // Dispose of Persistent wrapper around input Buffers so they can be garbage collected
+    std::accumulate(buffersToPersist.begin(), buffersToPersist.end(), 0,
+      [this](uint32_t index, v8::Local<v8::Object> const buffer) -> uint32_t {
+        GetFromPersistent(index);
+        return index + 1;
+      }
+    );
+    delete baton->input;
     delete baton;
 
     // Return to JavaScript
@@ -202,32 +127,27 @@ class MetadataWorker : public AsyncWorker {
 
  private:
   MetadataBaton* baton;
+  std::vector<v8::Local<v8::Object>> buffersToPersist;
 };
 
 /*
   metadata(options, callback)
 */
 NAN_METHOD(metadata) {
-  HandleScope();
+  // Input Buffers must not undergo GC compaction during processing
+  std::vector<v8::Local<v8::Object>> buffersToPersist;
 
   // V8 objects are converted to non-V8 types held in the baton struct
   MetadataBaton *baton = new MetadataBaton;
-  Local<Object> options = info[0].As<Object>();
+  v8::Local<v8::Object> options = info[0].As<v8::Object>();
 
-  // Input filename
-  baton->fileIn = *Utf8String(Get(options, New("fileIn").ToLocalChecked()).ToLocalChecked());
-  // Input Buffer object
-  Local<Object> bufferIn;
-  if (node::Buffer::HasInstance(Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked())) {
-    bufferIn = Get(options, New("bufferIn").ToLocalChecked()).ToLocalChecked().As<Object>();
-    baton->bufferInLength = node::Buffer::Length(bufferIn);
-    baton->bufferIn = node::Buffer::Data(bufferIn);
-  }
+  // Input
+  baton->input = sharp::CreateInputDescriptor(sharp::AttrAs<v8::Object>(options, "input"), buffersToPersist);
 
   // Join queue for worker thread
-  Callback *callback = new Callback(info[1].As<Function>());
-  AsyncQueueWorker(new MetadataWorker(callback, baton, bufferIn));
+  Nan::Callback *callback = new Nan::Callback(info[1].As<v8::Function>());
+  Nan::AsyncQueueWorker(new MetadataWorker(callback, baton, buffersToPersist));
 
   // Increment queued task counter
-  g_atomic_int_inc(&counterQueue);
+  g_atomic_int_inc(&sharp::counterQueue);
 }

src/metadata.h

@@ -2,6 +2,41 @@
 #define SRC_METADATA_H_
 
 #include "nan.h"
+#include "common.h"
+
+struct MetadataBaton {
+  // Input
+  sharp::InputDescriptor *input;
+  // Output
+  std::string format;
+  int width;
+  int height;
+  std::string space;
+  int channels;
+  int density;
+  bool hasProfile;
+  bool hasAlpha;
+  int orientation;
+  char *exif;
+  size_t exifLength;
+  char *icc;
+  size_t iccLength;
+  std::string err;
+
+  MetadataBaton():
+    input(nullptr),
+    width(0),
+    height(0),
+    channels(0),
+    density(0),
+    hasProfile(false),
+    hasAlpha(false),
+    orientation(0),
+    exif(nullptr),
+    exifLength(0),
+    icc(nullptr),
+    iccLength(0) {}
+};
 
 NAN_METHOD(metadata);
 

src/operations.cc

@@ -1,4 +1,6 @@
 #include <algorithm>
+#include <functional>
+#include <memory>
 #include <tuple>
 #include <vips/vips8>
 
@@ -15,6 +17,49 @@ namespace sharp {
     Assumes alpha channels are already premultiplied and will be unpremultiplied after.
    */
   VImage Composite(VImage src, VImage dst, const int gravity) {
+    if(IsInputValidForComposition(src, dst)) {
+      // Enlarge overlay src, if required
+      if (src.width() < dst.width() || src.height() < dst.height()) {
+        // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
+        int left;
+        int top;
+        std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), src.width(), src.height(), gravity);
+        // Embed onto transparent background
+        std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+        src = src.embed(left, top, dst.width(), dst.height(), VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background)
+        );
+      }
+      return CompositeImage(src, dst);
+    }
+    // If the input was not valid for composition the return the input image itself
+    return dst;
+  }
+
+
+  VImage Composite(VImage src, VImage dst, const int x, const int y) {
+    if(IsInputValidForComposition(src, dst)) {
+      // Enlarge overlay src, if required
+      if (src.width() < dst.width() || src.height() < dst.height()) {
+        // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
+        int left;
+        int top;
+        std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), src.width(), src.height(), x, y);
+        // Embed onto transparent background
+        std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+        src = src.embed(left, top, dst.width(), dst.height(), VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background)
+        );
+      }
+      return CompositeImage(src, dst);
+    }
+    // If the input was not valid for composition the return the input image itself
+    return dst;
+  }
+
+  bool IsInputValidForComposition(VImage src, VImage dst) {
     using sharp::CalculateCrop;
     using sharp::HasAlpha;
 
@@ -28,20 +73,10 @@ namespace sharp {
       throw VError("Overlay image must have same dimensions or smaller");
     }
 
-    // Enlarge overlay src, if required
-    if (src.width() < dst.width() || src.height() < dst.height()) {
-      // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
-      int left;
-      int top;
-      std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), src.width(), src.height(), gravity);
-      // Embed onto transparent background
-      std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
-      src = src.embed(left, top, dst.width(), dst.height(), VImage::option()
-        ->set("extend", VIPS_EXTEND_BACKGROUND)
-        ->set("background", background)
-      );
-    }
+    return true;
+  }
 
+  VImage CompositeImage(VImage src, VImage dst) {
     // Split src into non-alpha and alpha channels
     VImage srcWithoutAlpha = src.extract_band(0, VImage::option()->set("n", src.bands() - 1));
     VImage srcAlpha = src[src.bands() - 1] * (1.0 / 255.0);
@@ -81,6 +116,65 @@ namespace sharp {
     return outRGBPremultiplied.bandjoin(outAlphaNormalized * 255.0);
   }
 
+  /*
+    Cutout src over dst with given gravity.
+   */
+  VImage Cutout(VImage mask, VImage dst, const int gravity) {
+    using sharp::CalculateCrop;
+    using sharp::HasAlpha;
+    using sharp::MaximumImageAlpha;
+
+    bool maskHasAlpha = HasAlpha(mask);
+
+    if (!maskHasAlpha && mask.bands() > 1) {
+      throw VError("Overlay image must have an alpha channel or one band");
+    }
+    if (!HasAlpha(dst)) {
+      throw VError("Image to be overlaid must have an alpha channel");
+    }
+    if (mask.width() > dst.width() || mask.height() > dst.height()) {
+      throw VError("Overlay image must have same dimensions or smaller");
+    }
+
+    // Enlarge overlay mask, if required
+    if (mask.width() < dst.width() || mask.height() < dst.height()) {
+      // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
+      int left;
+      int top;
+      std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), mask.width(), mask.height(), gravity);
+      // Embed onto transparent background
+      std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+      mask = mask.embed(left, top, dst.width(), dst.height(), VImage::option()
+              ->set("extend", VIPS_EXTEND_BACKGROUND)
+              ->set("background", background)
+      );
+    }
+
+    // we use the mask alpha if it has alpha
+    if(maskHasAlpha) {
+      mask = mask.extract_band(mask.bands() - 1, VImage::option()->set("n", 1));;
+    }
+
+    // Split dst into an optional alpha
+    VImage dstAlpha = dst.extract_band(dst.bands() - 1, VImage::option()->set("n", 1));
+
+    // we use the dst non-alpha
+    dst = dst.extract_band(0, VImage::option()->set("n", dst.bands() - 1));
+
+    // the range of the mask and the image need to match .. one could be
+    // 16-bit, one 8-bit
+    double const dstMax = MaximumImageAlpha(dst.interpretation());
+    double const maskMax = MaximumImageAlpha(mask.interpretation());
+
+    // combine the new mask and the existing alpha ... there are
+    // many ways of doing this, mult is the simplest
+    mask = dstMax * ((mask / maskMax) * (dstAlpha / dstMax));
+
+    // append the mask to the image data ... the mask might be float now,
+    // we must cast the format down to match the image data
+    return dst.bandjoin(mask.cast(dst.format()));
+  }
+
   /*
    * Stretch luminance to cover full dynamic range.
    */
@@ -135,10 +229,10 @@ namespace sharp {
   }
 
   /*
-   * Gaussian blur (use sigma <0 for fast blur)
+   * Gaussian blur. Use sigma of -1.0 for fast blur.
    */
   VImage Blur(VImage image, double const sigma) {
-    if (sigma < 0.0) {
+    if (sigma == -1.0) {
       // Fast, mild blur - averages neighbouring pixels
       VImage blur = VImage::new_matrixv(3, 3,
         1.0, 1.0, 1.0,
@@ -153,10 +247,30 @@ namespace sharp {
   }
 
   /*
-   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   * Convolution with a kernel.
    */
-  VImage Sharpen(VImage image, int const radius, double const flat, double const jagged) {
-    if (radius == -1) {
+  VImage Convolve(VImage image, int const width, int const height,
+    double const scale, double const offset,
+    std::unique_ptr<double[]> const &kernel_v
+  ) {
+    VImage kernel = VImage::new_from_memory(
+      kernel_v.get(),
+      width * height * sizeof(double),
+      width,
+      height,
+      1,
+      VIPS_FORMAT_DOUBLE);
+    kernel.set("scale", scale);
+    kernel.set("offset", offset);
+
+    return image.conv(kernel);
+  }
+
+  /*
+   * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
+   */
+  VImage Sharpen(VImage image, double const sigma, double const flat, double const jagged) {
+    if (sigma == -1.0) {
       // Fast, mild sharpen
       VImage sharpen = VImage::new_matrixv(3, 3,
         -1.0, -1.0, -1.0,
@@ -166,75 +280,114 @@ namespace sharp {
       return image.conv(sharpen);
     } else {
       // Slow, accurate sharpen in LAB colour space, with control over flat vs jagged areas
+      VipsInterpretation colourspaceBeforeSharpen = image.interpretation();
+      if (colourspaceBeforeSharpen == VIPS_INTERPRETATION_RGB) {
+        colourspaceBeforeSharpen = VIPS_INTERPRETATION_sRGB;
+      }
       return image.sharpen(
-        VImage::option()->set("radius", radius)->set("m1", flat)->set("m2", jagged)
-      );
+        VImage::option()->set("sigma", sigma)->set("m1", flat)->set("m2", jagged)
+      ).colourspace(colourspaceBeforeSharpen);
     }
   }
 
+  /*
+    Calculate the Shannon entropy
+  */
+  double EntropyStrategy::operator()(VImage image) {
+    return image.hist_find().hist_entropy();
+  }
+
+  /*
+    Calculate the intensity of edges, skin tone and saturation
+  */
+  double AttentionStrategy::operator()(VImage image) {
+    // Convert to LAB colourspace
+    VImage lab = image.colourspace(VIPS_INTERPRETATION_LAB);
+    VImage l = lab[0];
+    VImage a = lab[1];
+    VImage b = lab[2];
+    // Edge detect luminosity with the Sobel operator
+    VImage sobel = vips::VImage::new_matrixv(3, 3,
+      -1.0, 0.0, 1.0,
+      -2.0, 0.0, 2.0,
+      -1.0, 0.0, 1.0);
+    VImage edges = l.conv(sobel).abs() + l.conv(sobel.rot90()).abs();
+    // Skin tone chroma thresholds trained with http://humanae.tumblr.com/
+    VImage skin = (a >= 3) & (a <= 22) & (b >= 4) & (b <= 31);
+    // Chroma >~50% saturation
+    VImage lch = lab.colourspace(VIPS_INTERPRETATION_LCH);
+    VImage c = lch[1];
+    VImage saturation = c > 60;
+    // Find maximum in combined saliency mask
+    VImage mask = edges + skin + saturation;
+    return mask.max();
+  }
+
   /*
     Calculate crop area based on image entropy
   */
-  std::tuple<int, int> EntropyCrop(VImage image, int const outWidth, int const outHeight) {
+  std::tuple<int, int> Crop(
+    VImage image, int const outWidth, int const outHeight, std::function<double(VImage)> strategy
+  ) {
     int left = 0;
     int top = 0;
     int const inWidth = image.width();
     int const inHeight = image.height();
     if (inWidth > outWidth) {
-      // Reduce width by repeated removing slices from edge with lowest entropy
+      // Reduce width by repeated removing slices from edge with lowest score
       int width = inWidth;
-      double leftEntropy = 0.0;
-      double rightEntropy = 0.0;
+      double leftScore = 0.0;
+      double rightScore = 0.0;
       // Max width of each slice
       int const maxSliceWidth = static_cast<int>(ceil((inWidth - outWidth) / 8.0));
       while (width > outWidth) {
         // Width of current slice
         int const slice = std::min(width - outWidth, maxSliceWidth);
-        if (leftEntropy == 0.0) {
-          // Update entropy of left slice
-          leftEntropy = Entropy(image.extract_area(left, 0, slice, inHeight));
+        if (leftScore == 0.0) {
+          // Update score of left slice
+          leftScore = strategy(image.extract_area(left, 0, slice, inHeight));
         }
-        if (rightEntropy == 0.0) {
-          // Update entropy of right slice
-          rightEntropy = Entropy(image.extract_area(width - slice - 1, 0, slice, inHeight));
+        if (rightScore == 0.0) {
+          // Update score of right slice
+          rightScore = strategy(image.extract_area(width - slice - 1, 0, slice, inHeight));
         }
-        // Keep slice with highest entropy
-        if (leftEntropy >= rightEntropy) {
+        // Keep slice with highest score
+        if (leftScore >= rightScore) {
           // Discard right slice
-          rightEntropy = 0.0;
+          rightScore = 0.0;
         } else {
           // Discard left slice
-          leftEntropy = 0.0;
+          leftScore = 0.0;
           left = left + slice;
         }
         width = width - slice;
       }
     }
     if (inHeight > outHeight) {
-      // Reduce height by repeated removing slices from edge with lowest entropy
+      // Reduce height by repeated removing slices from edge with lowest score
       int height = inHeight;
-      double topEntropy = 0.0;
-      double bottomEntropy = 0.0;
+      double topScore = 0.0;
+      double bottomScore = 0.0;
       // Max height of each slice
       int const maxSliceHeight = static_cast<int>(ceil((inHeight - outHeight) / 8.0));
       while (height > outHeight) {
         // Height of current slice
         int const slice = std::min(height - outHeight, maxSliceHeight);
-        if (topEntropy == 0.0) {
-          // Update entropy of top slice
-          topEntropy = Entropy(image.extract_area(0, top, inWidth, slice));
+        if (topScore == 0.0) {
+          // Update score of top slice
+          topScore = strategy(image.extract_area(0, top, inWidth, slice));
         }
-        if (bottomEntropy == 0.0) {
-          // Update entropy of bottom slice
-          bottomEntropy = Entropy(image.extract_area(0, height - slice - 1, inWidth, slice));
+        if (bottomScore == 0.0) {
+          // Update score of bottom slice
+          bottomScore = strategy(image.extract_area(0, height - slice - 1, inWidth, slice));
         }
-        // Keep slice with highest entropy
-        if (topEntropy >= bottomEntropy) {
+        // Keep slice with highest score
+        if (topScore >= bottomScore) {
           // Discard bottom slice
-          bottomEntropy = 0.0;
+          bottomScore = 0.0;
         } else {
           // Discard top slice
-          topEntropy = 0.0;
+          topScore = 0.0;
           top = top + slice;
         }
         height = height - slice;
@@ -244,10 +397,95 @@ namespace sharp {
   }
 
   /*
-    Calculate the Shannon entropy for an image
+    Insert a tile cache to prevent over-computation of any previous operations in the pipeline
   */
-  double Entropy(VImage image) {
-    return image.hist_find().hist_entropy();
+  VImage TileCache(VImage image, double const factor) {
+    int tile_width;
+    int tile_height;
+    int scanline_count;
+    vips_get_tile_size(image.get_image(), &tile_width, &tile_height, &scanline_count);
+    double const need_lines = 1.2 * scanline_count / factor;
+    return image.tilecache(VImage::option()
+      ->set("tile_width", image.width())
+      ->set("tile_height", 10)
+      ->set("max_tiles", static_cast<int>(round(1.0 + need_lines / 10.0)))
+      ->set("access", VIPS_ACCESS_SEQUENTIAL)
+      ->set("threaded", TRUE)
+    );
+  }
+
+  VImage Threshold(VImage image, double const threshold, bool const thresholdGrayscale) {
+    if(!thresholdGrayscale) {
+      return image >= threshold;
+    }
+    return image.colourspace(VIPS_INTERPRETATION_B_W) >= threshold;
+  }
+
+  /*
+    Perform boolean/bitwise operation on image color channels - results in one channel image
+  */
+  VImage Bandbool(VImage image, VipsOperationBoolean const boolean) {
+    image = image.bandbool(boolean);
+    return image.copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_B_W));
+  }
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean) {
+    return image.boolean(imageR, boolean);
+  }
+
+  VImage Trim(VImage image, int const tolerance) {
+    using sharp::MaximumImageAlpha;
+    // An equivalent of ImageMagick's -trim in C++ ... automatically remove
+    // "boring" image edges.
+
+    // We use .project to sum the rows and columns of a 0/255 mask image, the first
+    // non-zero row or column is the object edge. We make the mask image with an
+    // amount-different-from-background image plus a threshold.
+
+    // find the value of the pixel at (0, 0) ... we will search for all pixels
+    // significantly different from this
+    std::vector<double> background = image(0, 0);
+
+    double const max = MaximumImageAlpha(image.interpretation());
+
+    // we need to smooth the image, subtract the background from every pixel, take
+    // the absolute value of the difference, then threshold
+    VImage mask = (image.median(3) - background).abs() > (max * tolerance / 100);
+
+    // sum mask rows and columns, then search for the first non-zero sum in each
+    // direction
+    VImage rows;
+    VImage columns = mask.project(&rows);
+
+    VImage profileLeftV;
+    VImage profileLeftH = columns.profile(&profileLeftV);
+
+    VImage profileRightV;
+    VImage profileRightH = columns.fliphor().profile(&profileRightV);
+
+    VImage profileTopV;
+    VImage profileTopH = rows.profile(&profileTopV);
+
+    VImage profileBottomV;
+    VImage profileBottomH = rows.flipver().profile(&profileBottomV);
+
+    int left = static_cast<int>(floor(profileLeftV.min()));
+    int right = columns.width() - static_cast<int>(floor(profileRightV.min()));
+    int top = static_cast<int>(floor(profileTopH.min()));
+    int bottom = rows.height() - static_cast<int>(floor(profileBottomH.min()));
+
+    int width = right - left;
+    int height = bottom - top;
+
+    if(width <= 0 || height <= 0) {
+      throw VError("Unexpected error while trimming. Try to lower the tolerance");
+    }
+
+    // and now crop the original image
+    return image.extract_area(left, top, width, height);
   }
 
 }  // namespace sharp

src/operations.h

@@ -1,6 +1,9 @@
 #ifndef SRC_OPERATIONS_H_
 #define SRC_OPERATIONS_H_
 
+#include <algorithm>
+#include <functional>
+#include <memory>
 #include <tuple>
 #include <vips/vips8>
 
@@ -14,6 +17,27 @@ namespace sharp {
    */
   VImage Composite(VImage src, VImage dst, const int gravity);
 
+  /*
+    Alpha composite src over dst with given x and y offsets.
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
+   */
+  VImage Composite(VImage src, VImage dst, const int x, const int y);
+
+  /*
+    Check if the src and dst Images for composition operation are valid
+  */
+  bool IsInputValidForComposition(VImage src, VImage dst);
+
+  /*
+    Given a valid src and dst, returns the composite of the two images
+  */
+  VImage CompositeImage(VImage src, VImage dst);
+
+  /*
+    Cutout src over dst with given gravity.
+  */
+  VImage Cutout(VImage src, VImage dst, const int gravity);
+
   /*
    * Stretch luminance to cover full dynamic range.
    */
@@ -25,24 +49,62 @@ namespace sharp {
   VImage Gamma(VImage image, double const exponent);
 
   /*
-   * Gaussian blur. Use sigma of -1 for fast blur.
+   * Gaussian blur. Use sigma of -1.0 for fast blur.
    */
   VImage Blur(VImage image, double const sigma);
 
   /*
-   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   * Convolution with a kernel.
    */
-  VImage Sharpen(VImage image, int const radius, double const flat, double const jagged);
+  VImage Convolve(VImage image, int const width, int const height,
+    double const scale, double const offset, std::unique_ptr<double[]> const &kernel_v);
 
   /*
-    Calculate crop area based on image entropy
-  */
-  std::tuple<int, int> EntropyCrop(VImage image, int const outWidth, int const outHeight);
+   * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
+   */
+  VImage Sharpen(VImage image, double const sigma, double const flat, double const jagged);
 
   /*
-    Calculate the Shannon entropy for an image
+    Crop strategy functors
   */
-  double Entropy(VImage image);
+  struct EntropyStrategy {
+    double operator()(VImage image);
+  };
+  struct AttentionStrategy {
+    double operator()(VImage image);
+  };
+
+  /*
+    Calculate crop area based on given strategy (Entropy, Attention)
+  */
+  std::tuple<int, int> Crop(
+    VImage image, int const outWidth, int const outHeight, std::function<double(VImage)> strategy
+  );
+
+  /*
+    Insert a tile cache to prevent over-computation of any previous operations in the pipeline
+  */
+  VImage TileCache(VImage image, double const factor);
+
+  /*
+    Threshold an image
+  */
+  VImage Threshold(VImage image, double const threshold, bool const thresholdColor);
+
+  /*
+    Perform boolean/bitwise operation on image color channels - results in one channel image
+  */
+  VImage Bandbool(VImage image, VipsOperationBoolean const boolean);
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean);
+
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, int const tolerance);
 
 }  // namespace sharp
 

src/pipeline.h

@@ -1,9 +1,12 @@
 #ifndef SRC_PIPELINE_H_
 #define SRC_PIPELINE_H_
 
+#include <memory>
+
 #include <vips/vips8>
 
 #include "nan.h"
+#include "common.h"
 
 NAN_METHOD(pipeline);
 
@@ -16,23 +19,20 @@ enum class Canvas {
 };
 
 struct PipelineBaton {
-  std::string fileIn;
-  char *bufferIn;
-  size_t bufferInLength;
+  sharp::InputDescriptor *input;
   std::string iccProfilePath;
   int limitInputPixels;
-  int density;
-  int rawWidth;
-  int rawHeight;
-  int rawChannels;
   std::string formatOut;
   std::string fileOut;
   void *bufferOut;
   size_t bufferOutLength;
-  std::string overlayFileIn;
-  char *overlayBufferIn;
-  size_t overlayBufferInLength;
+  sharp::InputDescriptor *overlay;
   int overlayGravity;
+  int overlayXOffset;
+  int overlayYOffset;
+  bool overlayTile;
+  bool overlayCutout;
+  std::vector<sharp::InputDescriptor *> joinChannelIn;
   int topOffsetPre;
   int leftOffsetPre;
   int widthPre;
@@ -46,15 +46,20 @@ struct PipelineBaton {
   int channels;
   Canvas canvas;
   int crop;
+  int cropCalcLeft;
+  int cropCalcTop;
+  std::string kernel;
   std::string interpolator;
   double background[4];
   bool flatten;
   bool negate;
   double blurSigma;
-  int sharpenRadius;
+  double sharpenSigma;
   double sharpenFlat;
   double sharpenJagged;
   int threshold;
+  bool thresholdGrayscale;
+  int trimTolerance;
   double gamma;
   bool greyscale;
   bool normalize;
@@ -79,34 +84,47 @@ struct PipelineBaton {
   std::string err;
   bool withMetadata;
   int withMetadataOrientation;
+  std::unique_ptr<double[]> convKernel;
+  int convKernelWidth;
+  int convKernelHeight;
+  double convKernelScale;
+  double convKernelOffset;
+  sharp::InputDescriptor *boolean;
+  VipsOperationBoolean booleanOp;
+  VipsOperationBoolean bandBoolOp;
+  int extractChannel;
+  VipsInterpretation colourspace;
   int tileSize;
   int tileOverlap;
+  VipsForeignDzContainer tileContainer;
   VipsForeignDzLayout tileLayout;
 
   PipelineBaton():
-    bufferInLength(0),
+    input(nullptr),
     limitInputPixels(0),
-    density(72),
-    rawWidth(0),
-    rawHeight(0),
-    rawChannels(0),
-    formatOut(""),
-    fileOut(""),
     bufferOutLength(0),
-    overlayBufferInLength(0),
+    overlay(nullptr),
     overlayGravity(0),
+    overlayXOffset(-1),
+    overlayYOffset(-1),
+    overlayTile(false),
+    overlayCutout(false),
     topOffsetPre(-1),
     topOffsetPost(-1),
     channels(0),
     canvas(Canvas::CROP),
     crop(0),
+    cropCalcLeft(-1),
+    cropCalcTop(-1),
     flatten(false),
     negate(false),
     blurSigma(0.0),
-    sharpenRadius(0),
+    sharpenSigma(0.0),
     sharpenFlat(1.0),
     sharpenJagged(2.0),
     threshold(0),
+    thresholdGrayscale(true),
+    trimTolerance(0),
     gamma(0.0),
     greyscale(false),
     normalize(false),
@@ -128,8 +146,18 @@ struct PipelineBaton {
     optimiseScans(false),
     withMetadata(false),
     withMetadataOrientation(-1),
+    convKernelWidth(0),
+    convKernelHeight(0),
+    convKernelScale(0.0),
+    convKernelOffset(0.0),
+    boolean(nullptr),
+    booleanOp(VIPS_OPERATION_BOOLEAN_LAST),
+    bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
+    extractChannel(-1),
+    colourspace(VIPS_INTERPRETATION_LAST),
     tileSize(256),
     tileOverlap(0),
+    tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),
     tileLayout(VIPS_FOREIGN_DZ_LAYOUT_DZ) {
       background[0] = 0.0;
       background[1] = 0.0;

src/utilities.cc

@@ -138,7 +138,9 @@ NAN_METHOD(format) {
 
   // Which load/save operations are available for each compressed format?
   Local<Object> format = New<Object>();
-  for (std::string f : {"jpeg", "png", "webp", "tiff", "magick", "openslide", "dz"}) {
+  for (std::string f : {
+    "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz", "ppm", "fits", "gif", "svg", "pdf", "v"
+  }) {
     // Input
     Local<Boolean> hasInputFile =
       New<Boolean>(vips_type_find("VipsOperation", (f + "load").c_str()));

test/bench/package.json

@@ -8,14 +8,14 @@
     "test": "VIPS_WARNING=0 node perf && node random && node parallel"
   },
   "devDependencies": {
-    "async": "^1.5.2",
-    "benchmark": "^2.1.0",
-    "gm": "^1.21.0",
+    "async": "^2.1.1",
+    "benchmark": "^2.1.1",
+    "gm": "^1.23.0",
     "imagemagick": "^0.1.3",
-    "imagemagick-native": "^1.9.2",
-    "jimp": "^0.2.20",
-    "lwip": "^0.0.8",
-    "semver": "^5.1.0"
+    "imagemagick-native": "^1.9.3",
+    "jimp": "^0.2.27",
+    "lwip": "^0.0.9",
+    "semver": "^5.3.0"
   },
   "license": "Apache-2.0",
   "engines": {

test/bench/perf.js

@@ -30,18 +30,15 @@ var fixtures = require('../fixtures');
 var width = 720;
 var height = 480;
 
-var magickFilterBilinear = 'Triangle';
-var magickFilterBicubic = 'Lanczos';
-
 // Disable libvips cache to ensure tests are as fair as they can be
 sharp.cache(false);
 // Enable use of SIMD
 sharp.simd(true);
 
 async.series({
-  'jpeg-linear': function(callback) {
+  'jpeg': function(callback) {
     var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    var jpegSuite = new Benchmark.Suite('jpeg-linear');
+    var jpegSuite = new Benchmark.Suite('jpeg');
     // jimp
     jpegSuite.add('jimp-buffer-buffer', {
       defer: true,
@@ -93,7 +90,7 @@ async.series({
             if (err) {
               throw err;
             }
-            image.resize(width, height, 'linear', function (err, image) {
+            image.resize(width, height, 'lanczos', function (err, image) {
               if (err) {
                 throw err;
               }
@@ -113,7 +110,7 @@ async.series({
             if (err) {
               throw err;
             }
-            image.resize(width, height, 'linear', function (err, image) {
+            image.resize(width, height, 'lanczos', function (err, image) {
               if (err) {
                 throw err;
               }
@@ -140,7 +137,7 @@ async.series({
           width: width,
           height: height,
           format: 'jpg',
-          filter: magickFilterBilinear
+          filter: 'Lanczos'
         }, function(err) {
           if (err) {
             throw err;
@@ -161,7 +158,7 @@ async.series({
             width: width,
             height: height,
             format: 'JPEG',
-            filter: magickFilterBilinear
+            filter: 'Lanczos'
           }, function (err, buffer) {
             if (err) {
               throw err;
@@ -179,7 +176,7 @@ async.series({
       fn: function(deferred) {
         gm(inputJpgBuffer)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .write(fixtures.outputJpg, function (err) {
             if (err) {
@@ -194,7 +191,7 @@ async.series({
       fn: function(deferred) {
         gm(inputJpgBuffer)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .toBuffer(function (err, buffer) {
             if (err) {
@@ -210,7 +207,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputJpg)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .write(fixtures.outputJpg, function (err) {
             if (err) {
@@ -225,7 +222,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputJpg)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .toBuffer(function (err, buffer) {
             if (err) {
@@ -243,7 +240,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputJpg, function(err) {
             if (err) {
               throw err;
@@ -257,7 +253,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -272,7 +267,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputJpg)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputJpg, function(err) {
             if (err) {
               throw err;
@@ -290,8 +284,7 @@ async.series({
           deferred.resolve();
         });
         var pipeline = sharp()
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear);
+          .resize(width, height);
         readable.pipe(pipeline).pipe(writable);
       }
     }).add('sharp-file-buffer', {
@@ -299,7 +292,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputJpg)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -314,19 +306,27 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer()
           .then(function(buffer) {
             assert.notStrictEqual(null, buffer);
             deferred.resolve();
           });
       }
-    }).add('sharp-sharpen-mild', {
+    }).on('cycle', function(event) {
+      console.log('jpeg ' + String(event.target));
+    }).on('complete', function() {
+      callback(null, this.filter('fastest').map('name'));
+    }).run();
+  },
+  // Effect of applying operations
+  operations: function(callback) {
+    var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
+    var operationsSuite = new Benchmark.Suite('operations');
+    operationsSuite.add('sharp-sharpen-mild', {
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .sharpen()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -342,7 +342,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .sharpen(3, 1, 3)
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -358,7 +357,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .blur()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -374,7 +372,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .blur(3)
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -390,7 +387,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .gamma()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -406,7 +402,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .normalise()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -422,7 +417,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .greyscale()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -438,7 +432,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .gamma()
           .greyscale()
           .toBuffer(function(err, buffer) {
@@ -455,7 +448,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .progressive()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -471,7 +463,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .withoutChromaSubsampling()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -487,7 +478,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .rotate(90)
-          .interpolateWith(sharp.interpolator.bilinear)
           .resize(width, height)
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -503,8 +493,6 @@ async.series({
       fn: function(deferred) {
         sharp.simd(false);
         sharp(inputJpgBuffer)
-          .rotate(90)
-          .interpolateWith(sharp.interpolator.bilinear)
           .resize(width, height)
           .toBuffer(function(err, buffer) {
             sharp.simd(true);
@@ -520,9 +508,38 @@ async.series({
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .sequentialRead()
+          .resize(width, height)
+          .toBuffer(function(err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-crop-entropy', {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .crop(sharp.strategy.entropy)
+          .toBuffer(function(err, buffer) {
+            if (err) {
+              throw err;
+            } else {
+              assert.notStrictEqual(null, buffer);
+              deferred.resolve();
+            }
+          });
+      }
+    }).add('sharp-crop-attention', {
+      defer: true,
+      fn: function(deferred) {
+        sharp(inputJpgBuffer)
+          .resize(width, height)
+          .crop(sharp.strategy.attention)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -533,189 +550,19 @@ async.series({
           });
       }
     }).on('cycle', function(event) {
-      console.log('jpeg-linear ' + String(event.target));
+      console.log('operations ' + String(event.target));
     }).on('complete', function() {
       callback(null, this.filter('fastest').map('name'));
     }).run();
   },
-
-  'jpeg-cubic': function(callback) {
+  // Comparitive speed of kernels
+  kernels: function(callback) {
     var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    var jpegSuite = new Benchmark.Suite('jpeg-cubic');
-    // lwip
-    if (typeof lwip !== 'undefined') {
-      jpegSuite.add('lwip-file-file', {
-        defer: true,
-        fn: function(deferred) {
-          lwip.open(fixtures.inputJpg, function (err, image) {
-            if (err) {
-              throw err;
-            }
-            image.resize(width, height, 'lanczos', 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, 'lanczos', 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();
-              });
-            });
-          });
-        }
-      });
-    }
-    // imagemagick
-    jpegSuite.add('imagemagick-file-file', {
-      defer: true,
-      fn: function(deferred) {
-        imagemagick.resize({
-          srcPath: fixtures.inputJpg,
-          dstPath: fixtures.outputJpg,
-          quality: 0.8,
-          width: width,
-          height: height,
-          format: 'jpg',
-          filter: magickFilterBicubic
-        }, function(err) {
-          if (err) {
-            throw err;
-          } else {
-            deferred.resolve();
-          }
-        });
-      }
-    });
-    // imagemagick-native
-    if (typeof imagemagickNative !== 'undefined') {
-      jpegSuite.add('imagemagick-native-buffer-buffer', {
-        defer: true,
-        fn: function(deferred) {
-          imagemagickNative.convert({
-            srcData: inputJpgBuffer,
-            quality: 80,
-            width: width,
-            height: height,
-            format: 'JPEG',
-            filter: magickFilterBicubic
-          }, function (err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-        }
-      });
-    }
-    // gm
-    jpegSuite.add('gm-buffer-file', {
-      defer: true,
-      fn: function(deferred) {
-        gm(inputJpgBuffer)
-          .resize(width, height)
-          .filter(magickFilterBicubic)
-          .quality(80)
-          .write(fixtures.outputJpg, function (err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('gm-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        gm(inputJpgBuffer)
-          .resize(width, height)
-          .filter(magickFilterBicubic)
-          .quality(80)
-          .toBuffer(function (err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('gm-file-file', {
-      defer: true,
-      fn: function(deferred) {
-        gm(fixtures.inputJpg)
-          .resize(width, height)
-          .filter(magickFilterBicubic)
-          .quality(80)
-          .write(fixtures.outputJpg, function (err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('gm-file-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        gm(fixtures.inputJpg)
-          .resize(width, height)
-          .filter(magickFilterBicubic)
-          .quality(80)
-          .toBuffer(function (err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    });
-    // sharp
-    jpegSuite.add('sharp-buffer-file', {
+    (new Benchmark.Suite('kernels')).add('sharp-cubic', {
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toFile(fixtures.outputJpg, function(err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
+          .resize(width, height, { kernel: 'cubic' })
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -725,39 +572,11 @@ async.series({
             }
           });
       }
-    }).add('sharp-file-file', {
+    }).add('sharp-lanczos2', {
       defer: true,
       fn: function(deferred) {
-        sharp(fixtures.inputJpg)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toFile(fixtures.outputJpg, function(err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-stream-stream', {
-      defer: true,
-      fn: function(deferred) {
-        var readable = fs.createReadStream(fixtures.inputJpg);
-        var writable = fs.createWriteStream(fixtures.outputJpg);
-        writable.on('finish', function() {
-          deferred.resolve();
-        });
-        var pipeline = sharp()
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic);
-        readable.pipe(pipeline).pipe(writable);
-      }
-    }).add('sharp-file-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(fixtures.inputJpg)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
+        sharp(inputJpgBuffer)
+          .resize(width, height, { kernel: 'lanczos2' })
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -767,109 +586,11 @@ async.series({
             }
           });
       }
-    }).add('sharp-promise', {
+    }).add('sharp-lanczos3', {
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toBuffer()
-          .then(function(buffer) {
-            assert.notStrictEqual(null, buffer);
-            deferred.resolve();
-          });
-      }
-    }).on('cycle', function(event) {
-      console.log('jpeg-cubic ' + String(event.target));
-    }).on('complete', function() {
-      callback(null, this.filter('fastest').map('name'));
-    }).run();
-  },
-
-  // Comparitive speed of pixel interpolators
-  interpolators: function(callback) {
-    var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    (new Benchmark.Suite('interpolators')).add('sharp-nearest-neighbour', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.nearest)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-bilinear', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-vertexSplitQuadraticBasisSpline', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.vertexSplitQuadraticBasisSpline)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-bicubic', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-locallyBoundedBicubic', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.locallyBoundedBicubic)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-nohalo', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.nohalo)
+          .resize(width, height, { kernel: 'lanczos3' })
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -880,12 +601,12 @@ async.series({
           });
       }
     }).on('cycle', function(event) {
-      console.log('interpolators ' + String(event.target));
+      console.log('kernels ' + String(event.target));
     }).on('complete', function() {
       callback(null, this.filter('fastest').map('name'));
     }).run();
   },
-
+  // PNG
   png: function(callback) {
     var inputPngBuffer = fs.readFileSync(fixtures.inputPng);
     var pngSuite = new Benchmark.Suite('png');
@@ -938,7 +659,7 @@ async.series({
             if (err) {
               throw err;
             }
-            image.resize(width, height, 'linear', function (err, image) {
+            image.resize(width, height, 'lanczos', function (err, image) {
               if (err) {
                 throw err;
               }
@@ -963,7 +684,7 @@ async.series({
           dstPath: fixtures.outputPng,
           width: width,
           height: height,
-          filter: magickFilterBilinear
+          filter: 'Lanczos'
         }, function(err) {
           if (err) {
             throw err;
@@ -983,7 +704,7 @@ async.series({
             width: width,
             height: height,
             format: 'PNG',
-            filter: magickFilterBilinear
+            filter: 'Lanczos'
           });
           deferred.resolve();
         }
@@ -995,7 +716,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputPng)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .write(fixtures.outputPng, function (err) {
             if (err) {
               throw err;
@@ -1009,7 +730,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputPng)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .toBuffer(function (err, buffer) {
             if (err) {
               throw err;
@@ -1026,7 +747,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputPng, function(err) {
             if (err) {
               throw err;
@@ -1040,7 +760,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -1055,7 +774,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputPng)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputPng, function(err) {
             if (err) {
               throw err;
@@ -1069,7 +787,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputPng)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -1084,7 +801,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .progressive()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -1100,7 +816,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .withoutAdaptiveFiltering()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -1118,7 +833,7 @@ async.series({
       callback(null, this.filter('fastest').map('name'));
     }).run();
   },
-
+  // WebP
   webp: function(callback) {
     var inputWebPBuffer = fs.readFileSync(fixtures.inputWebP);
     (new Benchmark.Suite('webp')).add('sharp-buffer-file', {
@@ -1126,7 +841,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputWebPBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputWebP, function(err) {
             if (err) {
               throw err;
@@ -1140,7 +854,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputWebPBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -1155,7 +868,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputWebP)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputWebP, function(err) {
             if (err) {
               throw err;
@@ -1169,7 +881,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputWebp)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;

test/bench/random.js

@@ -8,14 +8,12 @@ var Benchmark = require('benchmark');
 var sharp = require('../../index');
 var fixtures = require('../fixtures');
 
+sharp.cache(false);
 sharp.simd(true);
 
 var min = 320;
 var max = 960;
 
-// Nearest equivalent to bilinear
-var magickFilter = 'Triangle';
-
 var randomDimension = function() {
   return Math.ceil(Math.random() * (max - min) + min);
 };
@@ -30,7 +28,7 @@ new Benchmark.Suite('random').add('imagemagick', {
       width: randomDimension(),
       height: randomDimension(),
       format: 'jpg',
-      filter: magickFilter
+      filter: 'Lanczos'
     }, function(err) {
       if (err) {
         throw err;
@@ -44,7 +42,7 @@ new Benchmark.Suite('random').add('imagemagick', {
   fn: function(deferred) {
     gm(fixtures.inputJpg)
       .resize(randomDimension(), randomDimension())
-      .filter(magickFilter)
+      .filter('Lanczos')
       .quality(80)
       .toBuffer(function (err, buffer) {
         if (err) {
@@ -58,19 +56,20 @@ new Benchmark.Suite('random').add('imagemagick', {
 }).add('sharp', {
   defer: true,
   fn: function(deferred) {
-    sharp(fixtures.inputJpg).resize(randomDimension(), randomDimension()).toBuffer(function(err, buffer) {
-      if (err) {
-        throw err;
-      } else {
-        assert.notStrictEqual(null, buffer);
-        deferred.resolve();
-      }
-    });
+    sharp(fixtures.inputJpg)
+      .resize(randomDimension(), randomDimension())
+      .toBuffer(function(err, buffer) {
+        if (err) {
+          throw err;
+        } else {
+          assert.notStrictEqual(null, buffer);
+          deferred.resolve();
+        }
+      });
   }
 }).on('cycle', function(event) {
   console.log(String(event.target));
 }).on('complete', function() {
   var winner = this.filter('fastest').map('name');
   assert.strictEqual('sharp', String(winner), 'sharp was slower than ' + winner);
-  console.dir(sharp.cache());
 }).run();