Improve thread/buffer shutdown using new vips_thread_shutdown method - closes #5

.gitignore

@@ -13,5 +13,6 @@ results
 build
 node_modules
 tests/output.jpg
+tests/output.png
 
 npm-debug.log

.travis.yml

@@ -1,8 +0,0 @@
-language: node_js
-node_js:
-  - "0.11"
-  - "0.10"
-before_install:
- - sudo apt-get update -qq
- - sudo apt-get install -qq libvips-dev imagemagick
- - sudo ln -s /usr/lib/pkgconfig/vips-7.26.pc /usr/lib/pkgconfig/vips.pc

README.md

@@ -1,4 +1,4 @@
-# sharp
+# sharp
 
 _adj_
 
@@ -7,28 +7,23 @@ _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 performance Node.js module is to convert a large JPEG image to smaller JPEG images of varying dimensions.
+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.
 
-It is somewhat opinionated in that it only deals with JPEG images, always obeys the requested dimensions by either cropping or embedding and insists on a mild sharpen of the resulting image.
+It is somewhat opinionated in that it only deals with JPEG and PNG images, always obeys the requested dimensions by either cropping or embedding and insists on a mild sharpen of the resulting image.
 
-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 the University of Southampton. Speed is typically 25-30% faster than the imagemagick equivalent.
+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 the University of Southampton.
+
+Performance is 4x-8x faster than ImageMagick and 2x-4x faster than GraphicsMagick, based mainly on the number of CPU cores available.
 
 ## Prerequisites
 
-Requires node-gyp and libvips-dev to build.
+* Node.js v0.8+
+* node-gyp
+* [libvips](https://github.com/jcupitt/libvips) v7.37+
 
-	sudo npm install -g node-gyp
-	sudo apt-get install libvips-dev
+For the sharpest results, please compile libvips from source.
 
-Requires vips-7.xx.pc (installed with libvips-dev) to be symlinked as /usr/lib/pkgconfig/vips.pc
-
-Ubuntu 12.04 LTS:
-
-	sudo ln -s /usr/lib/pkgconfig/vips-7.26.pc /usr/lib/pkgconfig/vips.pc
-
-Ubuntu 13.04:
-
-	sudo ln -s /usr/lib/x86_64-linux-gnu/pkgconfig/vips-7.28.pc /usr/lib/pkgconfig/vips.pc
+If you prefer to run a stable, package-managed environment such as Ubuntu 12.04 LTS, [v0.0.3](https://github.com/lovell/sharp/tree/v0.0.3) will work with the libvips-dev package.
 
 ## Install
 
@@ -36,28 +31,129 @@ Ubuntu 13.04:
 
 ## Usage
 
+	var sharp = require("sharp");
+
+### crop(input, output, width, height, callback)
+
+Scale and crop to `width` x `height` calling `callback` when complete.
+
 ```javascript
-var sharp = require("sharp");
 sharp.crop("input.jpg", "output.jpg", 300, 200, function(err) {
   if (err) {
     throw err;
   }
-  // output.jpg is cropped input.jpg
+  // output.jpg is a 300 pixels wide and 200 pixels high image
+  // containing a scaled and cropped version of input.jpg
 });
+```
+
+```javascript
+sharp.crop("input.jpg", sharp.buffer.jpeg, 300, 200, function(err, buffer) {
+  if (err) {
+    throw err;
+  }
+  // buffer contains JPEG image data
+});
+```
+
+```javascript
+sharp.crop("input.jpg", sharp.buffer.png, 300, 200, function(err, buffer) {
+  if (err) {
+    throw err;
+  }
+  // buffer contains PNG image data (converted from JPEG)
+});
+```
+
+### embedWhite(input, output, width, height, callback)
+
+Scale and embed to `width` x `height` using a white canvas calling `callback` when complete.
+
+```javascript
 sharp.embedWhite("input.jpg", "output.jpg", 200, 300, function(err) {
   if (err) {
     throw err;
   }
-  // output.jpg contains input.jpg embedded with a white border
-});
-sharp.embedBlack("input.jpg", "output.jpg", 200, 300, function(err) {
-  if (err) {
-    throw err;
-  }
-  // output.jpg contains input.jpg embedded with a black border
+  // output.jpg is a 200 pixels wide and 300 pixels high image
+  // containing a scaled version of input.png embedded on a white canvas
 });
 ```
 
-## Testing [![Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
+```javascript
+sharp.embedWhite("input.jpg", sharp.buffer.jpeg, 200, 300, function(err, buffer) {
+  if (err) {
+    throw err;
+  }
+  // buffer contains JPEG image data
+});
+```
+
+### embedBlack(input, output, width, height, callback)
+
+Scale and embed to `width` x `height` using a black canvas calling `callback` when complete.
+
+```javascript
+sharp.embedBlack("input.png", "output.png", 200, 300, function(err) {
+  if (err) {
+    throw err;
+  }
+  // output.png is a 200 pixels wide and 300 pixels high image
+  // containing a scaled version of input.png embedded on a black canvas
+});
+```
+
+### Parameters common to all methods
+
+#### input
+
+String containing the filename to read from.
+
+#### output
+
+One of:
+* String containing the filename to write to.
+* `sharp.buffer.jpeg` to pass a Buffer containing JPEG image data to `callback`.
+* `sharp.buffer.png` to pass a Buffer containing PNG image data to `callback`.
+
+## Testing
 
 	npm test
+
+## Performance
+
+Test environment:
+
+* AMD Athlon 4 core 3.3GHz 512KB L2 CPU 1333 DDR3
+* libvips 7.37
+* libjpeg-turbo8 1.3.0
+* libpng 1.6.6
+* zlib1g 1.2.7
+
+#### JPEG
+
+* imagemagick x 5.53 ops/sec ±0.55% (31 runs sampled)
+* gm x 10.86 ops/sec ±0.43% (56 runs sampled)
+* epeg x 28.07 ops/sec ±0.07% (70 runs sampled)
+* sharp-file x 31.60 ops/sec ±8.80% (80 runs sampled)
+* sharp-buffer x 34.04 ops/sec ±0.36% (82 runs sampled)
+
+#### PNG
+
+* imagemagick x 4.65 ops/sec ±0.37% (27 runs sampled)
+* gm x 21.65 ops/sec ±0.18% (56 runs sampled)
+* sharp-file x 39.47 ops/sec ±6.78% (68 runs sampled)
+* sharp-buffer x 42.87 ops/sec ±0.19% (71 runs sampled)
+
+## Licence
+
+Copyright 2013, 2014 Lovell Fuller
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

binding.gyp

@@ -2,7 +2,10 @@
   'targets': [{
     'target_name': 'sharp',
     'sources': ['src/sharp.cc'],
-    'libraries': ['<!@(PKG_CONFIG_PATH="/usr/lib/pkgconfig" pkg-config --libs glib-2.0 vips)'],
+    'libraries': [
+      '<!@(PKG_CONFIG_PATH="/usr/local/lib/pkgconfig" pkg-config --libs vips)',
+      '<!@(PKG_CONFIG_PATH="/usr/lib/pkgconfig" pkg-config --libs vips)'
+    ],
     'include_dirs': [
       '/usr/include/glib-2.0',
       '/usr/lib/glib-2.0/include',

index.js

@@ -1,13 +1,18 @@
 var sharp = require("./build/Release/sharp");
 
+module.exports.buffer = {
+  jpeg: "__jpeg",
+  png: "__png"
+};
+
 module.exports.crop = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "c", callback)
-}
+  sharp.resize(input, output, width, height, "c", callback);
+};
 
 module.exports.embedWhite = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "w", callback)
-}
+  sharp.resize(input, output, width, height, "w", callback);
+};
 
 module.exports.embedBlack = function(input, output, width, height, callback) {
-  sharp.resize(input, output, width, height, "b", callback)
-}
+  sharp.resize(input, output, width, height, "b", callback);
+};

package.json

@@ -1,31 +1,37 @@
 {
   "name": "sharp",
-  "version": "0.0.1",
-  "main": "./build/Release/sharp",
-  "description": "High performance Node.js module to resize JPEG images using the libvips image processing library",
+  "version": "0.0.8",
+  "author": "Lovell Fuller",
+  "description": "High performance module to resize JPEG and PNG images using the libvips image processing library",
+  "scripts": {
+    "test": "node tests/perf.js"
+  },
+  "main": "index.js",
   "repository": {
     "type": "git",
     "url": "git://github.com/lovell/sharp"
   },
-  "devDependencies": {
-    "imagemagick": "*"
-  },
-  "scripts": {
-    "test": "node tests/perf.js"
-  },
-  "engines": {
-    "node": "*"
-  },
   "keywords": [
     "jpeg",
+    "png",
     "resize",
     "thumbnail",
-	"sharpen",
-	"crop",
-	"embed",
+    "sharpen",
+    "crop",
+    "embed",
     "libvips",
-	"fast"
+    "fast",
+    "buffer"
   ],
-  "author": "Lovell Fuller",
-  "license": "Apache 2.0"
+  "devDependencies": {
+    "imagemagick": "*",
+    "gm": "*",
+    "epeg": "*",
+    "async": "*",
+    "benchmark": "*"
+  },
+  "license": "Apache 2.0",
+  "engines": {
+    "node": ">=0.8"
+  }
 }

src/sharp.cc

@@ -3,8 +3,10 @@
 #include <string>
 #include <vector>
 #include <vips/vips.h>
+#include <node_buffer.h>
 
 using namespace v8;
+using namespace node;
 
 // Free VipsImage children when object goes out of scope
 // Thanks due to https://github.com/dosx/node-vips
@@ -27,19 +29,34 @@ class ImageFreer {
 struct ResizeBaton {
   std::string src;
   std::string dst;
+  void* buffer_out;
+  size_t buffer_out_len;
   int  cols;
   int  rows;
   bool crop;
   int  embed;
   std::string err;
   Persistent<Function> callback;
+
+  ResizeBaton() : buffer_out_len(0) {}
 };
 
+bool EndsWith(std::string const &str, std::string const &end) {
+  return str.length() >= end.length() && 0 == str.compare(str.length() - end.length(), end.length(), end);
+}
+
 void ResizeAsync(uv_work_t *work) {
   ResizeBaton* baton = static_cast<ResizeBaton*>(work->data);
 
   VipsImage *in = vips_image_new_mode((baton->src).c_str(), "p");
-  im_jpeg2vips((baton->src).c_str(), in);
+  if (EndsWith(baton->src, ".jpg") || EndsWith(baton->src, ".jpeg"))  {
+    vips_jpegload((baton->src).c_str(), &in, NULL);
+  } else if (EndsWith(baton->src, ".png")) {
+    vips_pngload((baton->src).c_str(), &in, NULL);
+  } else {
+    (baton->err).append("Unsupported input file type");
+    return;
+  }
   if (in == NULL) {
     (baton->err).append(vips_error_buffer());
     vips_error_clear();
@@ -114,10 +131,36 @@ void ResizeAsync(uv_work_t *work) {
   }
   img = t[3];
 
-  if (im_vips2jpeg(img, baton->dst.c_str())) {
-    (baton->err).append(vips_error_buffer());
-    vips_error_clear();
-  }  
+  if (baton->dst == "__jpeg") {
+    // Write JPEG to buffer
+    if (vips_jpegsave_buffer(img, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "Q", 80, "optimize_coding", TRUE, NULL)) {
+      (baton->err).append(vips_error_buffer());
+      vips_error_clear();
+      return;
+    }
+  } else if (baton->dst == "__png") {
+    // Write PNG to buffer
+    if (vips_pngsave_buffer(img, &baton->buffer_out, &baton->buffer_out_len, "strip", TRUE, "compression", 6, "interlace", FALSE, NULL)) {
+      (baton->err).append(vips_error_buffer());
+      vips_error_clear();
+      return;
+    }
+  } else if (EndsWith(baton->dst, ".jpg") || EndsWith(baton->dst, ".jpeg"))  {
+    // Write JPEG to file
+    if (vips_foreign_save(img, baton->dst.c_str(), "strip", TRUE, "Q", 80, "optimize_coding", TRUE, NULL)) {
+      (baton->err).append(vips_error_buffer());
+      vips_error_clear();
+    }
+  } else if (EndsWith(baton->dst, ".png")) {
+    // Write PNG to file
+    if (vips_foreign_save(img, baton->dst.c_str(), "strip", TRUE, "compression", 6, "interlace", FALSE, NULL)) {
+      (baton->err).append(vips_error_buffer());
+      vips_error_clear();
+    }
+  } else {
+    (baton->err).append("Unsupported output file type");
+  }
+  vips_thread_shutdown();
 }
 
 void ResizeAsyncAfter(uv_work_t *work, int status) {
@@ -125,14 +168,19 @@ void ResizeAsyncAfter(uv_work_t *work, int status) {
 
   ResizeBaton *baton = static_cast<ResizeBaton*>(work->data);
 
-  Local<Value> argv[1];
+  Local<Value> null = Local<Value>::New(Null());
+  Local<Value> argv[2] = {null, null};
   if (!baton->err.empty()) {
+    // Error
     argv[0] = String::New(baton->err.data(), baton->err.size());
-  } else {
-    argv[0] = Local<Value>::New(Null());
+  } else if (baton->buffer_out_len > 0) {
+    // Buffer
+    Buffer *buffer = Buffer::New((const char*)(baton->buffer_out), baton->buffer_out_len);
+    argv[1] = Local<Object>::New(buffer->handle_);
+    vips_free(baton->buffer_out);
   }
 
-  baton->callback->Call(Context::GetCurrent()->Global(), 1, argv);
+  baton->callback->Call(Context::GetCurrent()->Global(), 2, argv);
   baton->callback.Dispose();
   delete baton;
   delete work;
@@ -148,14 +196,14 @@ Handle<Value> Resize(const Arguments& args) {
   baton->rows = args[3]->Int32Value();
   Local<String> canvas = args[4]->ToString();
   if (canvas->Equals(String::NewSymbol("c"))) {
-	baton->crop = true;
+    baton->crop = true;
   } else if (canvas->Equals(String::NewSymbol("w"))) {
     baton->crop = false;
     baton->embed = 4;
   } else if (canvas->Equals(String::NewSymbol("b"))) {
     baton->crop = false;
     baton->embed = 0;
-  }	
+  }
   baton->callback = Persistent<Function>::New(Local<Function>::Cast(args[5]));
 
   uv_work_t *work = new uv_work_t;
@@ -164,10 +212,16 @@ Handle<Value> Resize(const Arguments& args) {
   return Undefined();
 }
 
+static void at_exit(void* arg) {
+  HandleScope scope;
+  vips_shutdown();
+}
+
 extern "C" void init(Handle<Object> target) {
   HandleScope scope;
   vips_init("");
+  AtExit(at_exit);
   NODE_SET_METHOD(target, "resize", Resize);
 };
 
-NODE_MODULE(sharp, init)
+NODE_MODULE(sharp, init);

tests/perf.js

@@ -1,42 +1,150 @@
 var sharp = require("../index");
 var imagemagick = require("imagemagick");
+var gm = require("gm");
+var epeg = require("epeg");
+var async = require("async");
 var assert = require("assert");
+var Benchmark = require("benchmark");
 
-// http://www.flickr.com/photos/grizdave/2569067123/
-var input = __dirname + "/2569067123_aca715a2ee_o.jpg";
-var output = __dirname + "/output.jpg";
+var inputJpg = __dirname + "/2569067123_aca715a2ee_o.jpg"; // http://www.flickr.com/photos/grizdave/2569067123/
+var outputJpg = __dirname + "/output.jpg";
+var outputJpgLength = 47035;
+
+var inputPng = __dirname + "/50020484-00001.png"; // http://c.searspartsdirect.com/lis_png/PLDM/50020484-00001.png
+var outputPng = __dirname + "/output.png";
+var outputPngLength = 60380;
 
 var width = 640;
 var height = 480;
 
-// imagemagick
-var time = process.hrtime();
-imagemagick.resize({
-  srcPath: input,
-  dstPath: output,
-  quality: 0.75,
-  width: width,
-  height: height
-}, function(err) {
-  if (err) {
-    throw err;
+async.series({
+  jpeg: function(callback) {
+    (new Benchmark.Suite("jpeg")).add("imagemagick", {
+      defer: true,
+      fn: function(deferred) {
+        imagemagick.resize({
+          srcPath: inputJpg,
+          dstPath: outputJpg,
+          quality: 0.8,
+          width: width,
+          height: height
+        }, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("gm", {
+      defer: true,
+      fn: function(deferred) {
+        gm(inputJpg).crop(width, height).quality(80).write(outputJpg, function (err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("epeg", {
+      defer: true,
+      fn: function(deferred) {
+        var image = new epeg.Image({path: inputJpg});
+        image.downsize(width, height, 80).saveTo(outputJpg);
+        deferred.resolve();
+      }
+    }).add("sharp-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.crop(inputJpg, outputJpg, width, height, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.crop(inputJpg, sharp.buffer.jpeg, width, height, function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            assert.strictEqual(outputJpgLength, buffer.length);
+            deferred.resolve();
+          }
+        });
+      }
+    }).on("cycle", function(event) {
+      console.log("jpeg " + String(event.target));
+    }).on("complete", function() {
+      callback(null, this.filter("fastest").pluck("name"));
+    }).run();
+  },
+  png: function(callback) {
+    (new Benchmark.Suite("png")).add("imagemagick", {
+      defer: true,
+      fn: function(deferred) {
+        imagemagick.resize({
+          srcPath: inputPng,
+          dstPath: outputPng,
+          width: width,
+          height: height
+        }, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("gm", {
+      defer: true,
+      fn: function(deferred) {
+        gm(inputPng).crop(width, height).write(outputPng, function (err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-file", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.crop(inputPng, outputPng, width, height, function(err) {
+          if (err) {
+            throw err;
+          } else {
+            deferred.resolve();
+          }
+        });
+      }
+    }).add("sharp-buffer", {
+      defer: true,
+      fn: function(deferred) {
+        sharp.crop(inputPng, sharp.buffer.png, width, height, function(err, buffer) {
+          if (err) {
+            throw err;
+          } else {
+            assert.notStrictEqual(null, buffer);
+            assert.strictEqual(outputPngLength, buffer.length);
+            deferred.resolve();
+          }
+        });
+      }
+    }).on("cycle", function(event) {
+      console.log(" png " + String(event.target));
+    }).on("complete", function() {
+      callback(null, this.filter("fastest").pluck("name"));
+    }).run();
   }
-  var diff = process.hrtime(time);
-  imagemagickTime = diff[0] * 1e9 + diff[1];
-  console.log("imagemagick took %d nanoseconds", imagemagickTime);
-
-  // sharp
-  time = process.hrtime();
-  sharp.crop(input, output, width, height, function(err) {
-    if (err) {
-      throw err;
-    }
-    diff = process.hrtime(time);
-	var sharpTime = diff[0] * 1e9 + diff[1];
-    console.log("sharp took %d nanoseconds", sharpTime);
-
-	// diff
-	assert(sharpTime < imagemagickTime, "sharp was blunt");
-	console.log("sharp was %d%% faster", (imagemagickTime - sharpTime) / imagemagickTime * 100);
+}, 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);
   });
 });