mirror of
https://github.com/lovell/sharp.git
synced 2025-07-17 05:50:15 +02:00
293 lines
9.4 KiB
C++
Executable File
293 lines
9.4 KiB
C++
Executable File
#include <node.h>
|
|
#include <node_buffer.h>
|
|
#include <math.h>
|
|
#include <string>
|
|
#include <string.h>
|
|
#include <vips/vips.h>
|
|
|
|
using namespace v8;
|
|
using namespace node;
|
|
|
|
struct resize_baton {
|
|
std::string file_in;
|
|
void* buffer_in;
|
|
size_t buffer_in_len;
|
|
std::string file_out;
|
|
void* buffer_out;
|
|
size_t buffer_out_len;
|
|
int width;
|
|
int height;
|
|
bool crop;
|
|
VipsExtend extend;
|
|
bool sharpen;
|
|
bool progessive;
|
|
VipsAccess access_method;
|
|
std::string err;
|
|
Persistent<Function> callback;
|
|
|
|
resize_baton(): buffer_in_len(0), buffer_out_len(0) {}
|
|
};
|
|
|
|
typedef enum {
|
|
JPEG,
|
|
PNG
|
|
} ImageType;
|
|
|
|
unsigned char MARKER_JPEG[] = {0xff, 0xd8};
|
|
unsigned char MARKER_PNG[] = {0x89, 0x50};
|
|
|
|
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");
|
|
}
|
|
|
|
bool is_png(std::string const &str) {
|
|
return ends_with(str, ".png");
|
|
}
|
|
|
|
void resize_error(resize_baton *baton, VipsImage *unref) {
|
|
(baton->err).append(vips_error_buffer());
|
|
vips_error_clear();
|
|
g_object_unref(unref);
|
|
vips_thread_shutdown();
|
|
return;
|
|
}
|
|
|
|
void resize_async(uv_work_t *work) {
|
|
resize_baton* baton = static_cast<resize_baton*>(work->data);
|
|
|
|
ImageType inputImageType = JPEG;
|
|
VipsImage *in = vips_image_new();
|
|
if (baton->buffer_in_len > 1) {
|
|
if (memcmp(MARKER_JPEG, baton->buffer_in, 2) == 0) {
|
|
if (vips_jpegload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "access", baton->access_method, NULL)) {
|
|
return resize_error(baton, in);
|
|
}
|
|
} else if(memcmp(MARKER_PNG, baton->buffer_in, 2) == 0) {
|
|
inputImageType = PNG;
|
|
if (vips_pngload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "access", baton->access_method, NULL)) {
|
|
return resize_error(baton, in);
|
|
}
|
|
}
|
|
} else if (is_jpeg(baton->file_in)) {
|
|
if (vips_jpegload((baton->file_in).c_str(), &in, "access", baton->access_method, NULL)) {
|
|
return resize_error(baton, in);
|
|
}
|
|
} else if (is_png(baton->file_in)) {
|
|
inputImageType = PNG;
|
|
if (vips_pngload((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);
|
|
return;
|
|
}
|
|
|
|
double xfactor = static_cast<double>(in->Xsize) / std::max(baton->width, 1);
|
|
double yfactor = static_cast<double>(in->Ysize) / std::max(baton->height, 1);
|
|
double factor = baton->crop ? std::min(xfactor, yfactor) : std::max(xfactor, yfactor);
|
|
factor = std::max(factor, 1.0);
|
|
int shrink = floor(factor);
|
|
double residual = shrink / factor;
|
|
|
|
// Try to use libjpeg shrink-on-load
|
|
int shrink_on_load = 1;
|
|
if (inputImageType == JPEG) {
|
|
if (shrink >= 8) {
|
|
factor = residual * shrink / 8;
|
|
shrink_on_load = 8;
|
|
shrink = floor(factor);
|
|
residual = shrink / factor;
|
|
} else if (shrink >= 4) {
|
|
factor = residual * shrink / 4;
|
|
shrink_on_load = 4;
|
|
shrink = floor(factor);
|
|
residual = shrink / factor;
|
|
} else if (shrink >= 2) {
|
|
factor = residual * shrink / 2;
|
|
shrink_on_load = 2;
|
|
shrink = floor(factor);
|
|
residual = shrink / factor;
|
|
}
|
|
if (shrink_on_load > 1) {
|
|
g_object_unref(in);
|
|
in = vips_image_new();
|
|
if (baton->buffer_in_len > 1) {
|
|
if (vips_jpegload_buffer(baton->buffer_in, baton->buffer_in_len, &in, "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)) {
|
|
return resize_error(baton, in);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VipsImage *shrunk = vips_image_new();
|
|
if (shrink > 1) {
|
|
// Use vips_shrink with the integral reduction
|
|
if (vips_shrink(in, &shrunk, shrink, shrink, NULL)) {
|
|
return resize_error(baton, in);
|
|
}
|
|
} else {
|
|
vips_copy(in, &shrunk, NULL);
|
|
}
|
|
g_object_unref(in);
|
|
|
|
// 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 && affined->Xsize != baton->width && affined->Ysize != baton->height) {
|
|
// Crop
|
|
int width = std::min(affined->Xsize, baton->width);
|
|
int height = std::min(affined->Ysize, baton->height);
|
|
int left = (affined->Xsize - width + 1) / 2;
|
|
int top = (affined->Ysize - height + 1) / 2;
|
|
if (vips_extract_area(affined, &canvased, left, top, width, height, NULL)) {
|
|
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, 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
|
|
VipsImage *sharpened = vips_image_new();
|
|
if (baton->sharpen) {
|
|
INTMASK* sharpen = im_create_imaskv("sharpen", 3, 3,
|
|
-1, -1, -1,
|
|
-1, 32, -1,
|
|
-1, -1, -1);
|
|
sharpen->scale = 24;
|
|
if (im_conv(canvased, sharpened, sharpen)) {
|
|
return resize_error(baton, canvased);
|
|
}
|
|
} else {
|
|
vips_copy(canvased, &sharpened, NULL);
|
|
}
|
|
g_object_unref(canvased);
|
|
|
|
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)) {
|
|
return resize_error(baton, canvased);
|
|
}
|
|
} 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)) {
|
|
return resize_error(baton, canvased);
|
|
}
|
|
} 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)) {
|
|
return resize_error(baton, canvased);
|
|
}
|
|
} 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)) {
|
|
return resize_error(baton, canvased);
|
|
}
|
|
} else {
|
|
(baton->err).append("Unsupported output " + baton->file_out);
|
|
}
|
|
g_object_unref(canvased);
|
|
vips_thread_shutdown();
|
|
}
|
|
|
|
void resize_async_after(uv_work_t *work, int status) {
|
|
HandleScope scope;
|
|
|
|
resize_baton *baton = static_cast<resize_baton*>(work->data);
|
|
|
|
Handle<Value> argv[2] = { Null(), Null() };
|
|
if (!baton->err.empty()) {
|
|
// Error
|
|
argv[0] = String::New(baton->err.data(), baton->err.size());
|
|
} else if (baton->buffer_out_len > 0) {
|
|
// Buffer
|
|
Buffer *slowBuffer = Buffer::New(baton->buffer_out_len);
|
|
memcpy(Buffer::Data(slowBuffer), baton->buffer_out, baton->buffer_out_len);
|
|
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);
|
|
g_free(baton->buffer_out);
|
|
}
|
|
|
|
baton->callback->Call(Context::GetCurrent()->Global(), 2, argv);
|
|
baton->callback.Dispose();
|
|
delete baton;
|
|
delete work;
|
|
}
|
|
|
|
Handle<Value> resize(const Arguments& args) {
|
|
HandleScope scope;
|
|
|
|
resize_baton *baton = new resize_baton;
|
|
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->file_out = *String::Utf8Value(args[2]->ToString());
|
|
baton->width = args[3]->Int32Value();
|
|
baton->height = args[4]->Int32Value();
|
|
Local<String> canvas = args[5]->ToString();
|
|
if (canvas->Equals(String::NewSymbol("c"))) {
|
|
baton->crop = true;
|
|
} else if (canvas->Equals(String::NewSymbol("w"))) {
|
|
baton->crop = false;
|
|
baton->extend = VIPS_EXTEND_WHITE;
|
|
} else if (canvas->Equals(String::NewSymbol("b"))) {
|
|
baton->crop = false;
|
|
baton->extend = VIPS_EXTEND_BLACK;
|
|
}
|
|
baton->sharpen = args[6]->BooleanValue();
|
|
baton->progessive = args[7]->BooleanValue();
|
|
baton->access_method = args[8]->BooleanValue() ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
|
|
baton->callback = Persistent<Function>::New(Local<Function>::Cast(args[9]));
|
|
|
|
uv_work_t *work = new uv_work_t;
|
|
work->data = baton;
|
|
uv_queue_work(uv_default_loop(), work, resize_async, (uv_after_work_cb)resize_async_after);
|
|
return scope.Close(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);
|