support node 0.10.x

binding.gyp

@@ -0,0 +1,44 @@
+{
+    "targets": [
+        {
+            "target_name": "jpeg",
+            "sources": [
+                "src/common.cpp",
+                "src/jpeg_encoder.cpp",
+                "src/jpeg.cpp",
+                "src/fixed_jpeg_stack.cpp",
+                "src/dynamic_jpeg_stack.cpp",
+                "src/module.cpp",
+            ],
+            "conditions" : [
+                [
+                    'OS=="linux"', {
+                        "libraries" : [
+                            '-ljpeg'
+                        ],
+                        'cflags!': [ '-fno-exceptions' ],
+                        'cflags_cc!': [ '-fno-exceptions' ]
+                    }
+                ],
+                [
+                    'OS=="mac"', {
+                        'xcode_settings': {
+                            'GCC_ENABLE_CPP_EXCEPTIONS': 'YES'
+                        },
+                        "libraries" : [
+                            '-ljpeg'
+                        ]
+                    }
+                ],
+                [
+                    'OS=="win"', {
+                        "include_dirs" : [ "gyp/include" ],
+                        "libraries" : [
+                            '<(module_root_dir)/gyp/lib/libjpeg.lib'
+                        ]
+                    }
+                ]
+            ]
+        }
+    ]
+}

package.json

@@ -29,7 +29,7 @@
        "node": ">=0.1.93"
    },
    "scripts": {
-       "install": "node-waf configure build"
+       "install": "node-gyp configure build"
    }
 }
 

src/dynamic_jpeg_stack.cpp

@@ -378,7 +378,7 @@ DynamicJpegStack::SetQuality(const Arguments &args)
 }
 
 void
-DynamicJpegStack::EIO_JpegEncode(eio_req *req)
+DynamicJpegStack::UV_JpegEncode(uv_work_t *req)
 {
     encode_request *enc_req = (encode_request *)req->data;
     DynamicJpegStack *jpeg = (DynamicJpegStack *)enc_req->jpeg_obj;
@@ -391,7 +391,7 @@ DynamicJpegStack::EIO_JpegEncode(eio_req *req)
         enc_req->jpeg_len = encoder.get_jpeg_len();
         enc_req->jpeg = (char *)malloc(sizeof(*enc_req->jpeg)*enc_req->jpeg_len);
         if (!enc_req->jpeg) {
-            enc_req->error = strdup("malloc in DynamicJpegStack::EIO_JpegEncode failed.");
+            enc_req->error = strdup("malloc in DynamicJpegStack::UV_JpegEncode failed.");
             return;
         }
         else {
@@ -403,13 +403,13 @@ DynamicJpegStack::EIO_JpegEncode(eio_req *req)
     }
 }
 
-int 
-DynamicJpegStack::EIO_JpegEncodeAfter(eio_req *req)
+void 
+DynamicJpegStack::UV_JpegEncodeAfter(uv_work_t *req)
 {
     HandleScope scope;
 
-    ev_unref(EV_DEFAULT_UC);
     encode_request *enc_req = (encode_request *)req->data;
+    delete req;
     DynamicJpegStack *jpeg = (DynamicJpegStack *)enc_req->jpeg_obj;
 
     Handle<Value> argv[3];
@@ -440,8 +440,6 @@ DynamicJpegStack::EIO_JpegEncodeAfter(eio_req *req)
 
     jpeg->Unref();
     free(enc_req);
-
-    return 0;
 }
 
 Handle<Value>
@@ -468,9 +466,10 @@ DynamicJpegStack::JpegEncodeAsync(const Arguments &args)
     enc_req->jpeg_len = 0;
     enc_req->error = NULL;
 
-    eio_custom(EIO_JpegEncode, EIO_PRI_DEFAULT, EIO_JpegEncodeAfter, enc_req);
+    uv_work_t* req = new uv_work_t;
+    req->data = enc_req;
+    uv_queue_work(uv_default_loop(), req, UV_JpegEncode, (uv_after_work_cb)UV_JpegEncodeAfter);
 
-    ev_ref(EV_DEFAULT_UC);
     jpeg->Ref();
 
     return Undefined();

src/dynamic_jpeg_stack.h

@@ -21,8 +21,8 @@ class DynamicJpegStack : public node::ObjectWrap {
 
     void update_optimal_dimension(int x, int y, int w, int h);
 
-    static void EIO_JpegEncode(eio_req *req);
-    static int EIO_JpegEncodeAfter(eio_req *req);
+    static void UV_JpegEncode(uv_work_t *req);
+    static void UV_JpegEncodeAfter(uv_work_t *req);
 public:
     DynamicJpegStack(buffer_type bbuf_type);
     ~DynamicJpegStack();

src/fixed_jpeg_stack.cpp

@@ -248,7 +248,7 @@ FixedJpegStack::SetQuality(const Arguments &args)
 }
 
 void
-FixedJpegStack::EIO_JpegEncode(eio_req *req)
+FixedJpegStack::UV_JpegEncode(uv_work_t *req)
 {
     encode_request *enc_req = (encode_request *)req->data;
     FixedJpegStack *jpeg = (FixedJpegStack *)enc_req->jpeg_obj;
@@ -259,7 +259,7 @@ FixedJpegStack::EIO_JpegEncode(eio_req *req)
         enc_req->jpeg_len = encoder.get_jpeg_len();
         enc_req->jpeg = (char *)malloc(sizeof(*enc_req->jpeg)*enc_req->jpeg_len);
         if (!enc_req->jpeg) {
-            enc_req->error = strdup("malloc in FixedJpegStack::EIO_JpegEncode failed.");
+            enc_req->error = strdup("malloc in FixedJpegStack::UV_JpegEncode failed.");
             return;
         }
         else {
@@ -271,13 +271,13 @@ FixedJpegStack::EIO_JpegEncode(eio_req *req)
     }
 }
 
-int 
-FixedJpegStack::EIO_JpegEncodeAfter(eio_req *req)
+void 
+FixedJpegStack::UV_JpegEncodeAfter(uv_work_t *req)
 {
     HandleScope scope;
 
-    ev_unref(EV_DEFAULT_UC);
     encode_request *enc_req = (encode_request *)req->data;
+    delete req;
 
     Handle<Value> argv[2];
 
@@ -305,8 +305,6 @@ FixedJpegStack::EIO_JpegEncodeAfter(eio_req *req)
 
     ((FixedJpegStack *)enc_req->jpeg_obj)->Unref();
     free(enc_req);
-
-    return 0;
 }
 
 Handle<Value>
@@ -333,9 +331,9 @@ FixedJpegStack::JpegEncodeAsync(const Arguments &args)
     enc_req->jpeg_len = 0;
     enc_req->error = NULL;
 
-    eio_custom(EIO_JpegEncode, EIO_PRI_DEFAULT, EIO_JpegEncodeAfter, enc_req);
-
-    ev_ref(EV_DEFAULT_UC);
+    uv_work_t* req = new uv_work_t;
+    req->data = enc_req;
+    uv_queue_work(uv_default_loop(), req, UV_JpegEncode, (uv_after_work_cb)UV_JpegEncodeAfter);
     jpeg->Ref();
 
     return Undefined();

src/fixed_jpeg_stack.h

@@ -13,8 +13,8 @@ class FixedJpegStack : public node::ObjectWrap {
 
     unsigned char *data;
 
-    static void EIO_JpegEncode(eio_req *req);
-    static int EIO_JpegEncodeAfter(eio_req *req);
+    static void UV_JpegEncode(uv_work_t *req);
+    static void UV_JpegEncodeAfter(uv_work_t *req);
 
 public:
     static void Initialize(v8::Handle<v8::Object> target);

src/jpeg.cpp

@@ -168,7 +168,7 @@ v8::Handle<v8::Value> Jpeg::SetSmoothing(const v8::Arguments &args)
 }
 
 void
-Jpeg::EIO_JpegEncode(eio_req *req)
+Jpeg::UV_JpegEncode(uv_work_t *req)
 {
     encode_request *enc_req = (encode_request *)req->data;
     Jpeg *jpeg = (Jpeg *)enc_req->jpeg_obj;
@@ -178,7 +178,7 @@ Jpeg::EIO_JpegEncode(eio_req *req)
         enc_req->jpeg_len = jpeg->jpeg_encoder.get_jpeg_len();
         enc_req->jpeg = (char *)malloc(sizeof(*enc_req->jpeg)*enc_req->jpeg_len);
         if (!enc_req->jpeg) {
-            enc_req->error = strdup("malloc in Jpeg::EIO_JpegEncode failed.");
+            enc_req->error = strdup("malloc in Jpeg::UV_JpegEncode failed.");
             return;
         }
         else {
@@ -190,13 +190,13 @@ Jpeg::EIO_JpegEncode(eio_req *req)
     }
 }
 
-int 
-Jpeg::EIO_JpegEncodeAfter(eio_req *req)
+void 
+Jpeg::UV_JpegEncodeAfter(uv_work_t *req)
 {
     HandleScope scope;
 
-    ev_unref(EV_DEFAULT_UC);
     encode_request *enc_req = (encode_request *)req->data;
+    delete req;
 
     Handle<Value> argv[2];
 
@@ -224,8 +224,6 @@ Jpeg::EIO_JpegEncodeAfter(eio_req *req)
 
     ((Jpeg *)enc_req->jpeg_obj)->Unref();
     free(enc_req);
-
-    return 0;
 }
 
 Handle<Value>
@@ -252,9 +250,10 @@ Jpeg::JpegEncodeAsync(const Arguments &args)
     enc_req->jpeg_len = 0;
     enc_req->error = NULL;
 
-    eio_custom(EIO_JpegEncode, EIO_PRI_DEFAULT, EIO_JpegEncodeAfter, enc_req);
+    uv_work_t* req = new uv_work_t;
+    req->data = enc_req;
+    uv_queue_work(uv_default_loop(), req, UV_JpegEncode, (uv_after_work_cb)UV_JpegEncodeAfter);
 
-    ev_ref(EV_DEFAULT_UC);
     jpeg->Ref();
 
     return Undefined();

src/jpeg.h

@@ -9,8 +9,8 @@
 class Jpeg : public node::ObjectWrap {
     JpegEncoder jpeg_encoder;
 
-    static void EIO_JpegEncode(eio_req *req);
-    static int EIO_JpegEncodeAfter(eio_req *req);
+    static void UV_JpegEncode(uv_work_t *req);
+    static void UV_JpegEncodeAfter(uv_work_t *req);
 public:
     static void Initialize(v8::Handle<v8::Object> target);
     Jpeg(unsigned char *ddata, int wwidth, int hheight, buffer_type bbuf_type);

src/module.cpp

@@ -14,4 +14,5 @@ init(Handle<Object> target)
     FixedJpegStack::Initialize(target);
     DynamicJpegStack::Initialize(target);
 }
+NODE_MODULE(jpeg, init)