Expose vips internal cache settings and status

.gitignore

@@ -12,7 +12,6 @@ logs
 results
 build
 node_modules
-tests/output.jpg
+tests/output.*
-tests/output.png
 
 npm-debug.log

README.md

@@ -7,12 +7,14 @@ _adj_
 3. shrewd or astute: a sharp bargainer. 
 4. (Informal.) very stylish: a sharp dresser; a sharp jacket. 
 
-The typical use case for this high speed Node.js module is to convert large JPEG and PNG images to smaller JPEG and PNG images of varying dimensions.
+The typical use case for this high speed Node.js module is to convert large JPEG, PNG, WebP and TIFF images to smaller images of varying dimensions.
+
+The performance of JPEG resizing is typically 15x-25x faster than ImageMagick and GraphicsMagick, based mainly on the number of CPU cores available.
+
+This module supports reading and writing images to and from both the filesystem and Buffer objects (TIFF is limited to filesystem only). Everything remains non-blocking thanks to _libuv_.
 
 Under the hood you'll find the blazingly fast [libvips](https://github.com/jcupitt/libvips) image processing library, originally created in 1989 at Birkbeck College and currently maintained by John Cupitt.
 
-Performance is up to 18x faster than ImageMagick and up to 8x faster than GraphicsMagick, based mainly on the number of CPU cores available.
-
 ## Prerequisites
 
 * Node.js v0.8+
@@ -32,9 +34,9 @@ For the sharpest results, please compile libvips from source.
 
 Scale and crop to `width` x `height` calling `callback` when complete.
 
-`input` can either be a filename String or a Buffer. When using a filename libvips will `mmap` the file for improved performance. 
+`input` can either be a filename String or a Buffer.
 
-`output` can either be a filename String or one of `sharp.buffer.jpeg` or `sharp.buffer.png` to pass a Buffer containing image data to `callback`.
+`output` can either be a filename String or one of `sharp.buffer.jpeg`, `sharp.buffer.png` or `sharp.buffer.webp` to pass a Buffer containing JPEG, PNG or WebP image data to `callback`.
 
 `width` is the Number of pixels wide the resultant image should be.
 
@@ -49,7 +51,7 @@ Scale and crop to `width` x `height` calling `callback` when complete.
 
 `callback` gets two arguments `(err, buffer)` where `err` is an error message, if any, and `buffer` is the resultant image data when a Buffer is requested.
 
-### Examples
+#### Examples
 
 ```javascript
 sharp.resize("input.jpg", "output.jpg", 300, 200, function(err) {
@@ -71,7 +73,7 @@ sharp.resize("input.jpg", sharp.buffer.jpeg, 300, 200, {progressive: true}, func
 ```
 
 ```javascript
-sharp.resize("input.jpg", sharp.buffer.png, 300, 200, {sharpen: true}, function(err, buffer) {
+sharp.resize("input.webp", sharp.buffer.png, 300, 200, {sharpen: true}, function(err, buffer) {
   if (err) {
     throw err;
   }
@@ -80,25 +82,39 @@ sharp.resize("input.jpg", sharp.buffer.png, 300, 200, {sharpen: true}, function(
 ```
 
 ```javascript
-sharp.resize(buffer, "output.jpg", 200, 300, {canvas: sharp.canvas.embedWhite}, function(err) {
+sharp.resize(buffer, "output.tiff", 200, 300, {canvas: sharp.canvas.embedWhite}, function(err) {
   if (err) {
     throw err;
   }
-  // output.jpg is a 200 pixels wide and 300 pixels high image containing a scaled version
+  // output.tiff is a 200 pixels wide and 300 pixels high image containing a scaled version
   // of the image data contained in buffer embedded on a white canvas
 });
 ```
 
 ```javascript
-sharp.resize("input.jpg", sharp.buffer.jpeg, 200, 300, {canvas: sharp.canvas.embedBlack}, function(err, buffer) {
+sharp.resize("input.jpg", sharp.buffer.webp, 200, 300, {canvas: sharp.canvas.embedBlack}, function(err, buffer) {
   if (err) {
     throw err;
   }
-  // buffer contains JPEG image data of a 200 pixels wide and 300 pixels high image
+  // buffer contains WebP image data of a 200 pixels wide and 300 pixels high image
   // containing a scaled version of input.png embedded on a black canvas
 });
 ```
 
+### cache([limit])
+
+If `limit` is provided, set the `vips` internal cache limit to this value in MB. The default value is 100.
+
+Always returns cache statistics, namely current usage, high water mark and maximum limit.
+
+The high water mark may be higher than the maximum limit.
+
+```javascript
+var stats = sharp.cache(); // { current: 98, high: 115, limit: 100 }
+sharp.cache(200); // { current: 98, high: 115, limit: 200 }
+sharp.cache(50); // { current: 49, high: 115, limit: 50 }
+```
+
 ## Testing
 
 	npm test
@@ -108,10 +124,12 @@ sharp.resize("input.jpg", sharp.buffer.jpeg, 200, 300, {canvas: sharp.canvas.emb
 Test environment:
 
 * AMD Athlon 4 core 3.3GHz 512KB L2 CPU 1333 DDR3
-* libvips 7.37
+* libvips 7.38
 * libjpeg-turbo8 1.3.0
 * libpng 1.6.6
 * zlib1g 1.2.7
+* libwebp 0.3.0
+* libtiff 4.0.2
 
 `-file-buffer` indicates read from file and write to buffer, `-buffer-file` indicates read from buffer and write to file etc.
 
@@ -119,35 +137,50 @@ Test environment:
 
 ### JPEG
 
-* imagemagick x 5.50 ops/sec ±0.48% (31 runs sampled)
+* imagemagick x 5.53 ops/sec ±0.62% (31 runs sampled)
-* gm-file-file x 11.19 ops/sec ±0.51% (57 runs sampled)
+* gm-file-file x 4.10 ops/sec ±0.41% (25 runs sampled)
-* gm-file-buffer x 11.11 ops/sec ±0.42% (57 runs sampled)
+* gm-file-buffer x 4.10 ops/sec ±0.36% (25 runs sampled)
-* epeg-file-file x 28.59 ops/sec ±0.09% (71 runs sampled)
+* epeg-file-file x 23.82 ops/sec ±0.18% (60 runs sampled)
-* epeg-file-buffer x 28.67 ops/sec ±0.14% (71 runs sampled)
+* epeg-file-buffer x 23.98 ops/sec ±0.16% (61 runs sampled)
 
-* sharp-buffer-file x 24.72 ops/sec ±0.42% (62 runs sampled)
+* sharp-buffer-file x 20.76 ops/sec ±0.55% (54 runs sampled)
-* sharp-buffer-buffer x 24.24 ops/sec ±0.36% (61 runs sampled)
+* sharp-buffer-buffer x 20.90 ops/sec ±0.26% (54 runs sampled)
-* sharp-file-file x 97.15 ops/sec ±0.44% (80 runs sampled)
+* sharp-file-file x 91.78 ops/sec ±0.38% (88 runs sampled)
-* sharp-file-buffer x __98.51 ops/sec__ ±0.42% (80 runs sampled)
+* sharp-file-buffer x __93.05 ops/sec__ ±0.61% (76 runs sampled)
 
-* sharp-file-buffer-sharpen x 56.99 ops/sec ±5.43% (57 runs sampled)
+* sharp-file-buffer-sharpen x 63.09 ops/sec ±5.58% (63 runs sampled)
-* sharp-file-buffer-progressive x 64.89 ops/sec ±0.42% (79 runs sampled)
+* sharp-file-buffer-progressive x 61.68 ops/sec ±0.53% (76 runs sampled)
-* sharp-file-buffer-sequentialRead x 64.13 ops/sec ±0.40% (78 runs sampled)
+* sharp-file-buffer-sequentialRead x 60.66 ops/sec ±0.38% (75 runs sampled)
 
 ### PNG
 
-* imagemagick x 4.31 ops/sec ±0.27% (26 runs sampled)
+* imagemagick x 4.27 ops/sec ±0.21% (25 runs sampled)
-* gm-file-file x 17.89 ops/sec ±0.21% (86 runs sampled)
+* gm-file-file x 8.33 ops/sec ±0.19% (44 runs sampled)
-* gm-file-buffer x 14.74 ops/sec ±0.15% (73 runs sampled)
+* gm-file-buffer x 7.45 ops/sec ±0.16% (40 runs sampled)
  
-* sharp-buffer-file x 4.97 ops/sec ±120.47% (26 runs sampled)
+* sharp-buffer-file x 4.94 ops/sec ±118.46% (26 runs sampled)
-* sharp-buffer-buffer x 13.00 ops/sec ±0.53% (65 runs sampled)
+* sharp-buffer-buffer x 12.59 ops/sec ±0.55% (64 runs sampled)
-* sharp-file-file x 53.00 ops/sec ±7.15% (88 runs sampled)
+* sharp-file-file x 44.06 ops/sec ±6.86% (75 runs sampled)
-* sharp-file-buffer x __55.43 ops/sec__ ±0.65% (89 runs sampled)
+* sharp-file-buffer x __46.29 ops/sec__ ±0.38% (76 runs sampled)
 
-* sharp-file-buffer-sharpen x 45.37 ops/sec ±0.38% (74 runs sampled)
+* sharp-file-buffer-sharpen x 38.86 ops/sec ±0.22% (65 runs sampled)
-* sharp-file-buffer-progressive x 55.49 ops/sec ±0.45% (89 runs sampled)
+* sharp-file-buffer-progressive x 46.35 ops/sec ±0.20% (76 runs sampled)
-* sharp-file-buffer-sequentialRead x 32.27 ops/sec ±0.29% (79 runs sampled)
+* sharp-file-buffer-sequentialRead x 29.02 ops/sec ±0.62% (72 runs sampled)
+
+### WebP
+
+* sharp-buffer-file x 3.30 ops/sec ±117.14% (19 runs sampled)
+* sharp-buffer-buffer x 7.66 ops/sec ±5.83% (43 runs sampled)
+* sharp-file-file x 9.88 ops/sec ±0.98% (52 runs sampled)
+* sharp-file-buffer x 9.95 ops/sec ±0.25% (52 runs sampled)
+* sharp-file-buffer-sharpen x 9.05 ops/sec ±0.36% (48 runs sampled)
+* sharp-file-buffer-sequentialRead x 9.87 ops/sec ±0.98% (52 runs sampled)
+
+### TIFF
+
+* sharp-file-file x 68.24 ops/sec ±5.93% (85 runs sampled)
+* sharp-file-file-sharpen x 50.76 ops/sec ±0.52% (82 runs sampled)
+* sharp-file-file-sequentialRead x 36.37 ops/sec ±0.90% (87 runs sampled)
 
 ## Licence
 

binding.gyp

@@ -7,11 +7,13 @@
       '<!@(PKG_CONFIG_PATH="/usr/lib/pkgconfig" pkg-config --libs vips)'
     ],
     'include_dirs': [
+      '/usr/local/include/glib-2.0',
+      '/usr/local/lib/glib-2.0/include',
       '/usr/include/glib-2.0',
       '/usr/lib/glib-2.0/include',
       '/usr/lib/x86_64-linux-gnu/glib-2.0/include'
     ],
-    'cflags': ['-fexceptions', '-O3'],
+    'cflags': ['-fexceptions', '-pedantic', '-Wall', '-O3'],
-    'cflags_cc': ['-fexceptions', '-O3']
+    'cflags_cc': ['-fexceptions', '-pedantic', '-Wall', '-O3']
   }]
 }

index.js

@@ -2,7 +2,8 @@ var sharp = require("./build/Release/sharp");
 
 module.exports.buffer = {
   jpeg: "__jpeg",
-  png: "__png"
+  png: "__png",
+  webp: "__webp"
 };
 
 module.exports.canvas = {
@@ -52,6 +53,13 @@ module.exports.resize = function(input, output, width, height, options, callback
   sharp.resize(options.inFile, options.inBuffer, output, width, height, canvas, sharpen, progessive, sequentialRead, callback);
 };
 
+module.exports.cache = function(limit) {
+  if (Number.isNaN(limit)) {
+    limit = null;
+  }
+  return sharp.cache(limit);
+}
+
 /* Deprecated v0.0.x methods */
 module.exports.crop = function(input, output, width, height, sharpen, callback) {
   sharp.resize(input, output, width, height, {canvas: "c", sharpen: true}, callback);

package.json

@@ -1,8 +1,8 @@
 {
   "name": "sharp",
-  "version": "0.1.0",
+  "version": "0.1.7",
   "author": "Lovell Fuller",
-  "description": "High performance module to resize JPEG and PNG images using the libvips image processing library",
+  "description": "High performance module to resize JPEG, PNG, WebP and TIFF images using the libvips image processing library",
   "scripts": {
     "test": "node tests/perf.js"
   },
@@ -14,12 +14,15 @@
   "keywords": [
     "jpeg",
     "png",
+    "webp",
+    "tiff",
     "resize",
     "thumbnail",
     "sharpen",
     "crop",
     "embed",
     "libvips",
+    "vips",
     "fast",
     "buffer"
   ],

src/sharp.cc

@@ -18,7 +18,7 @@ struct resize_baton {
   int  width;
   int  height;
   bool crop;
-  int  embed;
+  VipsExtend extend;
   bool sharpen;
   bool progessive;
   VipsAccess access_method;
@@ -30,22 +30,33 @@ struct resize_baton {
 
 typedef enum {
   JPEG,
-  PNG
+  PNG,
+  WEBP,
+  TIFF
 } ImageType;
 
 unsigned char MARKER_JPEG[] = {0xff, 0xd8};
 unsigned char MARKER_PNG[] = {0x89, 0x50};
+unsigned char MARKER_WEBP[] = {0x52, 0x49};
 
 bool ends_with(std::string const &str, std::string const &end) {
   return str.length() >= end.length() && 0 == str.compare(str.length() - end.length(), end.length(), end);
 }
 
 bool is_jpeg(std::string const &str) {
-  return ends_with(str, ".jpg") || ends_with(str, ".jpeg");
+  return ends_with(str, ".jpg") || ends_with(str, ".jpeg") || ends_with(str, ".JPG") || ends_with(str, ".JPEG");
 }
 
 bool is_png(std::string const &str) {
-  return ends_with(str, ".png");
+  return ends_with(str, ".png") || ends_with(str, ".PNG");
+}
+
+bool is_webp(std::string const &str) {
+  return ends_with(str, ".webp") || ends_with(str, ".WEBP");
+}
+
+bool is_tiff(std::string const &str) {
+  return ends_with(str, ".tif") || ends_with(str, ".tiff") || ends_with(str, ".TIF") || ends_with(str, ".TIFF");
 }
 
 void resize_error(resize_baton *baton, VipsImage *unref) {
@@ -71,6 +82,15 @@ void resize_async(uv_work_t *work) {
       if (vips_pngload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "access", baton->access_method, NULL)) {
         return resize_error(baton, in);
       }
+    } else if(memcmp(MARKER_WEBP, baton->buffer_in, 2) == 0) {
+      inputImageType = WEBP;
+      if (vips_webpload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "access", baton->access_method, NULL)) {
+        return resize_error(baton, in);
+      }
+    } else {
+      resize_error(baton, in);
+      (baton->err).append("Unsupported input buffer");
+      return;
     }
   } else if (is_jpeg(baton->file_in)) {
     if (vips_jpegload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
@@ -81,9 +101,19 @@ void resize_async(uv_work_t *work) {
     if (vips_pngload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
       return resize_error(baton, in);
     }
+  } else if (is_webp(baton->file_in)) {
+    inputImageType = WEBP;
+    if (vips_webpload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
+      return resize_error(baton, in);
+    }
+  } else if (is_tiff(baton->file_in)) {
+    inputImageType = TIFF;
+    if (vips_tiffload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
+      return resize_error(baton, in);
+    }
   } else {
     resize_error(baton, in);
-    (baton->err).append("Unsupported input " + baton->file_in);
+    (baton->err).append("Unsupported input file " + baton->file_in);
     return;
   }
 
@@ -98,53 +128,63 @@ void resize_async(uv_work_t *work) {
   int shrink_on_load = 1;
   if (inputImageType == JPEG) {
     if (shrink >= 8) {
-      residual = residual * shrink / 8;
+      factor = factor / 8;
       shrink_on_load = 8;
-      shrink = 1;
     } else if (shrink >= 4) {
-      residual = residual * shrink / 4;
+      factor = factor / 4;
       shrink_on_load = 4;
-      shrink = 1;
     } else if (shrink >= 2) {
-      residual = residual * shrink / 2;
+      factor = factor / 2;
       shrink_on_load = 2;
-      shrink = 1;
     }
+  }
+  VipsImage *shrunk_on_load = vips_image_new();
   if (shrink_on_load > 1) {
-      g_object_unref(in);
+    // Recalculate integral shrink and double residual
-      in = vips_image_new();
+    factor = std::max(factor, 1.0);
+    shrink = floor(factor);
+    residual = shrink / factor;
+    // Reload input using shrink-on-load 
     if (baton->buffer_in_len > 1) {
-        if (vips_jpegload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "shrink", shrink_on_load, NULL)) {
+      if (vips_jpegload_buffer(baton->buffer_in, baton->buffer_in_len, &shrunk_on_load, "shrink", shrink_on_load, NULL)) {
         return resize_error(baton, in);
       }
     } else {
-        if (vips_jpegload((baton->file_in).c_str(), &in, "shrink", shrink_on_load, NULL)) {
+      if (vips_jpegload((baton->file_in).c_str(), &shrunk_on_load, "shrink", shrink_on_load, NULL)) {
         return resize_error(baton, in);
       }
     }
+  } else {
+    vips_copy(in, &shrunk_on_load, NULL);
   }
-  }
+  g_object_unref(in);
 
   VipsImage *shrunk = vips_image_new();
   if (shrink > 1) {
     // Use vips_shrink with the integral reduction
-    if (vips_shrink(in, &shrunk, shrink, shrink, NULL)) {
+    if (vips_shrink(shrunk_on_load, &shrunk, shrink, shrink, NULL)) {
-      return resize_error(baton, in);
+      return resize_error(baton, shrunk_on_load);
     }
   } else {
-    vips_copy(in, &shrunk, NULL);
+    vips_copy(shrunk_on_load, &shrunk, NULL);
   }
-  g_object_unref(in);
+  g_object_unref(shrunk_on_load);
 
   // Use vips_affine with the remaining float part using bilinear interpolation
   VipsImage *affined = vips_image_new();
+  if (residual > 0) {
     if (vips_affine(shrunk, &affined, residual, 0, 0, residual, "interpolate", vips_interpolate_bilinear_static(), NULL)) {
       return resize_error(baton, shrunk);
     }
+  } else {
+    vips_copy(shrunk, &affined, NULL);
+  }
   g_object_unref(shrunk);
 
   VipsImage *canvased = vips_image_new();
+  if (affined->Xsize != baton->width || affined->Ysize != baton->height) {
     if (baton->crop) {
+      // Crop
       int width = std::min(affined->Xsize, baton->width);
       int height = std::min(affined->Ysize, baton->height);
       int left = (affined->Xsize - width + 1) / 2;
@@ -153,12 +193,16 @@ void resize_async(uv_work_t *work) {
         return resize_error(baton, affined);
       }
     } else {
+      // Embed
       int left = (baton->width - affined->Xsize) / 2;
       int top = (baton->height - affined->Ysize) / 2;
-    if (vips_embed(affined, &canvased, baton->embed, left, top, baton->width, baton->height, NULL)) {
+      if (vips_embed(affined, &canvased, left, top, baton->width, baton->height, "extend", baton->extend, NULL)) {
         return resize_error(baton, affined);
       }
     }
+  } else {
+    vips_copy(affined, &canvased, NULL);
+  }
   g_object_unref(affined);
 
   // Mild sharpen
@@ -179,28 +223,43 @@ void resize_async(uv_work_t *work) {
 
   if (baton->file_out == "__jpeg") {
     // Write JPEG to buffer
-    if (vips_jpegsave_buffer(canvased, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", 80, "optimize_coding", TRUE, "interlace", baton->progessive, NULL)) {
+    if (vips_jpegsave_buffer(sharpened, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", 80, "optimize_coding", TRUE, "interlace", baton->progessive, NULL)) {
-      return resize_error(baton, canvased);
+      return resize_error(baton, sharpened);
     }
   } else if (baton->file_out == "__png") {
     // Write PNG to buffer
-    if (vips_pngsave_buffer(canvased, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "compression", 6, "interlace", baton->progessive, NULL)) {
+    if (vips_pngsave_buffer(sharpened, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "compression", 6, "interlace", baton->progessive, NULL)) {
-      return resize_error(baton, canvased);
+      return resize_error(baton, sharpened);
+    }
+  } else if (baton->file_out == "__webp") {
+    // Write WEBP to buffer
+    if (vips_webpsave_buffer(sharpened, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", 80, NULL)) {
+      return resize_error(baton, sharpened);
     }
   } else if (is_jpeg(baton->file_out))  {
     // Write JPEG to file
-    if (vips_jpegsave(canvased, baton->file_out.c_str(), "strip", TRUE, "Q", 80, "optimize_coding", TRUE, "interlace", baton->progessive, NULL)) {
+    if (vips_jpegsave(sharpened, baton->file_out.c_str(), "strip", TRUE, "Q", 80, "optimize_coding", TRUE, "interlace", baton->progessive, NULL)) {
-      return resize_error(baton, canvased);
+      return resize_error(baton, sharpened);
     }
   } else if (is_png(baton->file_out)) {
     // Write PNG to file
-    if (vips_pngsave(canvased, baton->file_out.c_str(), "strip", TRUE, "compression", 6, "interlace", baton->progessive, NULL)) {
+    if (vips_pngsave(sharpened, baton->file_out.c_str(), "strip", TRUE, "compression", 6, "interlace", baton->progessive, NULL)) {
-      return resize_error(baton, canvased);
+      return resize_error(baton, sharpened);
+    }
+  } else if (is_webp(baton->file_out)) {
+    // Write WEBP to file
+    if (vips_webpsave(sharpened, baton->file_out.c_str(), "strip", TRUE, "Q", 80, NULL)) {
+      return resize_error(baton, sharpened);
+    }
+  } else if (is_tiff(baton->file_out)) {
+    // Write TIFF to file
+    if (vips_tiffsave(sharpened, baton->file_out.c_str(), "strip", TRUE, "compression", VIPS_FOREIGN_TIFF_COMPRESSION_JPEG, "Q", 80, NULL)) {
+      return resize_error(baton, sharpened);
     }
   } else {
     (baton->err).append("Unsupported output " + baton->file_out);
   }
-  g_object_unref(canvased);
+  g_object_unref(sharpened);
   vips_thread_shutdown();
 }
 
@@ -212,7 +271,7 @@ void resize_async_after(uv_work_t *work, int status) {
   Handle<Value> argv[2] = { Null(), Null() };
   if (!baton->err.empty()) {
     // Error
-    argv[0] = String::New(baton->err.data(), baton->err.size());
+    argv[0] = scope.Close(String::New(baton->err.data(), baton->err.size()));
   } else if (baton->buffer_out_len > 0) {
     // Buffer
     Buffer *slowBuffer = Buffer::New(baton->buffer_out_len);
@@ -220,7 +279,7 @@ void resize_async_after(uv_work_t *work, int status) {
     Local<Object> globalObj = Context::GetCurrent()->Global();
     Local<Function> bufferConstructor = Local<Function>::Cast(globalObj->Get(String::New("Buffer")));
     Handle<Value> constructorArgs[3] = { slowBuffer->handle_, v8::Integer::New(baton->buffer_out_len), v8::Integer::New(0) };
-    argv[1] = bufferConstructor->NewInstance(3, constructorArgs);
+    argv[1] = scope.Close(bufferConstructor->NewInstance(3, constructorArgs));
     g_free(baton->buffer_out);
   }
 
@@ -237,8 +296,8 @@ Handle<Value> resize(const Arguments& args) {
   baton->file_in = *String::Utf8Value(args[0]->ToString());
   if (args[1]->IsObject()) {
     Local<Object> buffer = args[1]->ToObject();
-    baton->buffer_in = Buffer::Data(buffer);
     baton->buffer_in_len = Buffer::Length(buffer);
+    baton->buffer_in = Buffer::Data(buffer);
   }
   baton->file_out = *String::Utf8Value(args[2]->ToString());
   baton->width = args[3]->Int32Value();
@@ -248,10 +307,10 @@ Handle<Value> resize(const Arguments& args) {
     baton->crop = true;
   } else if (canvas->Equals(String::NewSymbol("w"))) {
     baton->crop = false;
-    baton->embed = 4;
+    baton->extend = VIPS_EXTEND_WHITE;
   } else if (canvas->Equals(String::NewSymbol("b"))) {
     baton->crop = false;
-    baton->embed = 0;
+    baton->extend = VIPS_EXTEND_BLACK;
   }
   baton->sharpen = args[6]->BooleanValue();
   baton->progessive = args[7]->BooleanValue();
@@ -264,6 +323,22 @@ Handle<Value> resize(const Arguments& args) {
   return scope.Close(Undefined());
 }
 
+Handle<Value> cache(const Arguments& args) {
+  HandleScope scope;
+  
+  // Set cache limit
+  if (args[0]->IsInt32()) {
+    vips_cache_set_max_mem(args[0]->Int32Value() * 1048576);
+  }
+
+  // Get cache statistics
+  Local<Object> cache = Object::New();
+  cache->Set(String::NewSymbol("current"), Number::New(vips_tracked_get_mem() / 1048576));
+  cache->Set(String::NewSymbol("high"), Number::New(vips_tracked_get_mem_highwater() / 1048576));
+  cache->Set(String::NewSymbol("limit"), Number::New(vips_cache_get_max_mem() / 1048576));
+  return scope.Close(cache);
+}
+
 static void at_exit(void* arg) {
   HandleScope scope;
   vips_shutdown();
@@ -274,6 +349,7 @@ extern "C" void init(Handle<Object> target) {
   vips_init("");
   AtExit(at_exit);
   NODE_SET_METHOD(target, "resize", resize);
-};
+  NODE_SET_METHOD(target, "cache", cache);
+}
 
-NODE_MODULE(sharp, init);
+NODE_MODULE(sharp, init)

tests/parallel.js

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

tests/perf.js

@@ -13,7 +13,13 @@ var outputJpg = __dirname + "/output.jpg";
 var inputPng = __dirname + "/50020484-00001.png"; // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
 var outputPng = __dirname + "/output.png";
 
-var width = 640;
+var inputWebp = __dirname + "/4.webp"; // http://www.gstatic.com/webp/gallery/4.webp
+var outputWebp = __dirname + "/output.webp";
+
+var inputTiff = __dirname + "/G31D.TIF"; // http://www.fileformat.info/format/tiff/sample/e6c9a6e5253348f4aef6d17b534360ab/index.htm
+var outputTiff = __dirname + "/output.tiff";
+
+var width = 720;
 var height = 480;
 
 async.series({
@@ -39,7 +45,7 @@ async.series({
     }).add("gm-file-file", {
       defer: true,
       fn: function(deferred) {
-        gm(inputJpg).crop(width, height).quality(80).write(outputJpg, function (err) {
+        gm(inputJpg).resize(width, height).quality(80).write(outputJpg, function (err) {
           if (err) {
             throw err;
           } else {
@@ -50,7 +56,7 @@ async.series({
     }).add("gm-file-buffer", {
       defer: true,
       fn: function(deferred) {
-        gm(inputJpg).crop(width, height).quality(80).toBuffer(function (err, buffer) {
+        gm(inputJpg).resize(width, height).quality(80).toBuffer(function (err, buffer) {
           if (err) {
             throw err;
           } else {
@@ -183,7 +189,7 @@ async.series({
     }).add("gm-file-file", {
       defer: true,
       fn: function(deferred) {
-        gm(inputPng).crop(width, height).write(outputPng, function (err) {
+        gm(inputPng).resize(width, height).write(outputPng, function (err) {
           if (err) {
             throw err;
           } else {
@@ -194,7 +200,7 @@ async.series({
     }).add("gm-file-buffer", {
       defer: true,
       fn: function(deferred) {
-        gm(inputPng).crop(width, height).quality(80).toBuffer(function (err, buffer) {
+        gm(inputPng).resize(width, height).quality(80).toBuffer(function (err, buffer) {
           if (err) {
             throw err;
           } else {
@@ -290,10 +296,129 @@ async.series({
     }).on("complete", function() {
       callback(null, this.filter("fastest").pluck("name"));
     }).run();
+  },
+  webp: function(callback) {
+    var inputWebpBuffer = fs.readFileSync(inputWebp);
+    (new Benchmark.Suite("webp")).add("sharp-buffer-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputWebpBuffer, outputWebp, width, height, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputWebpBuffer, sharp.buffer.webp, width, height, function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputWebp, outputWebp, width, height, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputWebp, sharp.buffer.webp, width, height, function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-sharpen", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputWebp, sharp.buffer.webp, width, height, {sharpen: true}, function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-buffer-sequentialRead", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputWebp, sharp.buffer.webp, width, height, {sequentialRead: true}, function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            deferred.resolve();
+          }
+        });
+      }
+    }).on("cycle", function(event) {
+      console.log("webp " + String(event.target));
+    }).on("complete", function() {
+      callback(null, this.filter("fastest").pluck("name"));
+    }).run();
+  },
+  tiff: function(callback) {
+    (new Benchmark.Suite("tiff")).add("sharp-file-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputTiff, outputTiff, width, height, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file-sharpen", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputTiff, outputTiff, width, height, {sharpen: true}, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file-file-sequentialRead", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.resize(inputTiff, outputTiff, width, height, {sequentialRead: true}, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).on("cycle", function(event) {
+      console.log("tiff " + String(event.target));
+    }).on("complete", function() {
+      callback(null, this.filter("fastest").pluck("name"));
+    }).run();
   }	
 }, function(err, results) {
   assert(!err, err);
   Object.keys(results).forEach(function(format) {
     assert.strictEqual("sharp", results[format].toString().substr(0, 5), "sharp was slower than " + results[format] + " for " + format);
   });
+  console.dir(sharp.cache());
 });