Expose vips internal cache settings and status

.gitignore

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

README.md

@@ -7,10 +7,12 @@ _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.
 
 ## Prerequisites
@@ -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.
 
@@ -149,6 +167,21 @@ Test environment:
 * sharp-file-buffer-progressive x 46.35 ops/sec ±0.20% (76 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
 
 Copyright 2013, 2014 Lovell Fuller

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.5",
+  "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

@@ -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;
   }
 
@@ -201,6 +231,11 @@ void resize_async(uv_work_t *work) {
     if (vips_pngsave_buffer(sharpened, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "compression", 6, "interlace", baton->progessive, NULL)) {
       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(sharpened, baton->file_out.c_str(), "strip", TRUE, "Q", 80, "optimize_coding", TRUE, "interlace", baton->progessive, NULL)) {
@@ -211,6 +246,16 @@ void resize_async(uv_work_t *work) {
     if (vips_pngsave(sharpened, baton->file_out.c_str(), "strip", TRUE, "compression", 6, "interlace", baton->progessive, NULL)) {
       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);
   }
@@ -223,11 +268,6 @@ void resize_async_after(uv_work_t *work, int status) {
 
   resize_baton *baton = static_cast<resize_baton*>(work->data);
 
-  // Free temporary copy of input buffer
-  if (baton->buffer_in_len > 0) {
-    g_free(baton->buffer_in);
-  }
-
   Handle<Value> argv[2] = { Null(), Null() };
   if (!baton->err.empty()) {
     // Error
@@ -256,12 +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();
-    // Take temporary copy of input buffer
-    if (Buffer::Length(buffer) > 0) {
-      baton->buffer_in_len = Buffer::Length(buffer);
-      baton->buffer_in = g_malloc(baton->buffer_in_len);
-      memcpy(baton->buffer_in, Buffer::Data(buffer), baton->buffer_in_len);
-    }
+    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();
@@ -287,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();
@@ -297,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)

tests/parallel.js

@@ -26,4 +26,6 @@ async.mapSeries([1, 1, 2, 4, 8, 16, 32, 64, 128], function(parallelism, next) {
       next();
     }
   );
-}, function() {});
+}, function() {
+  console.dir(sharp.cache());
+});

tests/perf.js

@@ -13,6 +13,12 @@ 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 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;
 
@@ -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());
 });