2020-07-12 15:14:39 +00:00
|
|
|
#include <napi.h>
|
2022-12-28 23:01:50 +00:00
|
|
|
|
|
|
|
#include <iostream>
|
2022-11-27 19:03:07 +00:00
|
|
|
#include <map>
|
|
|
|
#include <string>
|
|
|
|
|
2020-07-12 15:14:39 +00:00
|
|
|
#include "blur.h"
|
2022-12-28 20:24:22 +00:00
|
|
|
#include "bounce.h"
|
2020-07-23 20:49:34 +00:00
|
|
|
#include "caption.h"
|
|
|
|
#include "caption2.h"
|
2020-07-12 15:14:39 +00:00
|
|
|
#include "circle.h"
|
2022-12-28 23:01:50 +00:00
|
|
|
#include "colors.h"
|
|
|
|
#include "common.h"
|
2020-07-23 22:43:39 +00:00
|
|
|
#include "crop.h"
|
2021-06-29 22:26:22 +00:00
|
|
|
#include "deepfry.h"
|
2020-07-12 15:14:39 +00:00
|
|
|
#include "explode.h"
|
2020-07-14 14:53:51 +00:00
|
|
|
#include "flag.h"
|
|
|
|
#include "flip.h"
|
|
|
|
#include "freeze.h"
|
2020-07-16 14:31:48 +00:00
|
|
|
#include "gamexplain.h"
|
|
|
|
#include "globe.h"
|
2020-07-21 14:03:08 +00:00
|
|
|
#include "homebrew.h"
|
2020-07-12 15:14:39 +00:00
|
|
|
#include "invert.h"
|
2020-07-20 22:10:04 +00:00
|
|
|
#include "jpeg.h"
|
|
|
|
#include "magik.h"
|
|
|
|
#include "meme.h"
|
|
|
|
#include "mirror.h"
|
2020-07-22 18:12:38 +00:00
|
|
|
#include "motivate.h"
|
2021-04-26 14:47:03 +00:00
|
|
|
#include "reddit.h"
|
2020-07-22 18:12:38 +00:00
|
|
|
#include "resize.h"
|
|
|
|
#include "reverse.h"
|
|
|
|
#include "scott.h"
|
2021-06-15 03:03:48 +00:00
|
|
|
#include "snapchat.h"
|
2020-07-22 18:12:38 +00:00
|
|
|
#include "sonic.h"
|
2022-10-07 18:26:12 +00:00
|
|
|
#include "speed.h"
|
2020-07-23 00:54:58 +00:00
|
|
|
#include "spin.h"
|
2022-10-07 18:26:12 +00:00
|
|
|
#include "squish.h"
|
2022-12-28 23:01:50 +00:00
|
|
|
#include "swirl.h"
|
2020-07-23 00:54:58 +00:00
|
|
|
#include "tile.h"
|
2022-06-25 17:40:52 +00:00
|
|
|
#include "togif.h"
|
2022-07-30 21:00:09 +00:00
|
|
|
#include "uncanny.h"
|
2021-05-04 21:28:34 +00:00
|
|
|
#include "uncaption.h"
|
2020-07-23 20:49:34 +00:00
|
|
|
#include "wall.h"
|
2020-07-14 14:53:51 +00:00
|
|
|
#include "watermark.h"
|
2021-07-12 21:02:00 +00:00
|
|
|
#include "whisper.h"
|
2021-12-03 00:05:52 +00:00
|
|
|
#include "zamn.h"
|
2020-07-12 15:14:39 +00:00
|
|
|
|
2021-12-31 05:08:06 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include <Magick++.h>
|
|
|
|
#endif
|
2022-02-12 21:09:59 +00:00
|
|
|
#include <vips/vips8>
|
2021-12-31 05:08:06 +00:00
|
|
|
|
2022-11-27 19:03:07 +00:00
|
|
|
using namespace std;
|
|
|
|
|
2022-12-28 23:01:50 +00:00
|
|
|
std::map<std::string,
|
|
|
|
char* (*)(string* type, char* BufferData, size_t BufferLength,
|
|
|
|
ArgumentMap Arguments, size_t* DataSize)>
|
|
|
|
FunctionMap = {{"blur", &Blur},
|
|
|
|
{"bounce", &Bounce},
|
|
|
|
{"caption", &Caption},
|
|
|
|
{"captionTwo", &CaptionTwo},
|
|
|
|
{"circle", &Circle},
|
|
|
|
{"colors", &Colors},
|
|
|
|
{"crop", &Crop},
|
|
|
|
{"deepfry", &Deepfry},
|
|
|
|
{"explode", &Explode},
|
|
|
|
{"flag", &Flag},
|
|
|
|
{"flip", &Flip},
|
|
|
|
{"freeze", &Freeze},
|
|
|
|
{"gamexplain", Gamexplain},
|
|
|
|
{"globe", Globe},
|
|
|
|
{"invert", Invert},
|
|
|
|
{"jpeg", Jpeg},
|
|
|
|
{"magik", Magik},
|
|
|
|
{"meme", Meme},
|
|
|
|
{"mirror", Mirror},
|
|
|
|
{"motivate", Motivate},
|
|
|
|
{"reddit", Reddit},
|
|
|
|
{"resize", Resize},
|
|
|
|
{"reverse", Reverse},
|
|
|
|
{"scott", Scott},
|
|
|
|
{"snapchat", Snapchat},
|
|
|
|
{"speed", &Speed},
|
|
|
|
{"spin", Spin},
|
|
|
|
{"squish", Squish},
|
|
|
|
{"swirl", Swirl},
|
|
|
|
{"tile", Tile},
|
|
|
|
{"togif", ToGif},
|
|
|
|
{"uncanny", Uncanny},
|
|
|
|
{"uncaption", &Uncaption},
|
|
|
|
{"wall", Wall},
|
|
|
|
{"watermark", &Watermark},
|
|
|
|
{"whisper", Whisper},
|
|
|
|
{"zamn", Zamn}};
|
|
|
|
|
|
|
|
std::map<std::string,
|
|
|
|
char* (*)(string* type, ArgumentMap Arguments, size_t* DataSize)>
|
|
|
|
NoInputFunctionMap = {{"homebrew", Homebrew}, {"sonic", Sonic}};
|
2022-12-28 06:20:17 +00:00
|
|
|
|
2022-11-27 20:52:40 +00:00
|
|
|
bool isNapiValueInt(Napi::Env& env, Napi::Value& num) {
|
|
|
|
return env.Global()
|
|
|
|
.Get("Number")
|
|
|
|
.ToObject()
|
|
|
|
.Get("isInteger")
|
|
|
|
.As<Napi::Function>()
|
|
|
|
.Call({num})
|
|
|
|
.ToBoolean()
|
|
|
|
.Value();
|
|
|
|
}
|
|
|
|
|
2022-12-28 23:01:50 +00:00
|
|
|
Napi::Value ProcessImage(const Napi::CallbackInfo& info) {
|
2022-11-27 19:03:07 +00:00
|
|
|
Napi::Env env = info.Env();
|
|
|
|
Napi::Object result = Napi::Object::New(env);
|
|
|
|
|
|
|
|
try {
|
|
|
|
string command = info[0].As<Napi::String>().Utf8Value();
|
|
|
|
Napi::Object obj = info[1].As<Napi::Object>();
|
2022-12-28 23:01:50 +00:00
|
|
|
string type =
|
|
|
|
obj.Has("type") ? obj.Get("type").As<Napi::String>().Utf8Value() : NULL;
|
2022-11-27 19:03:07 +00:00
|
|
|
|
|
|
|
Napi::Array properties = obj.GetPropertyNames();
|
|
|
|
|
2022-12-03 19:49:28 +00:00
|
|
|
ArgumentMap Arguments;
|
2022-11-27 19:03:07 +00:00
|
|
|
|
|
|
|
for (unsigned int i = 0; i < properties.Length(); i++) {
|
2022-12-28 23:01:50 +00:00
|
|
|
string property =
|
|
|
|
properties.Get(uint32_t(i)).As<Napi::String>().Utf8Value();
|
2022-11-27 19:03:07 +00:00
|
|
|
|
|
|
|
if (property == "data") {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2022-11-27 20:52:40 +00:00
|
|
|
auto val = obj.Get(property);
|
|
|
|
if (val.IsBoolean()) {
|
|
|
|
Arguments[property] = val.ToBoolean().Value();
|
|
|
|
} else if (val.IsString()) {
|
|
|
|
Arguments[property] = val.ToString().As<Napi::String>().Utf8Value();
|
|
|
|
} else if (val.IsNumber()) {
|
|
|
|
auto num = val.ToNumber();
|
|
|
|
if (isNapiValueInt(env, num)) {
|
|
|
|
Arguments[property] = num.Int32Value();
|
|
|
|
} else {
|
|
|
|
Arguments[property] = num.FloatValue();
|
|
|
|
}
|
2022-12-03 19:49:28 +00:00
|
|
|
} else {
|
|
|
|
throw "Unimplemented value type passed to image native.";
|
2022-12-28 23:01:50 +00:00
|
|
|
// Arguments[property] = val;
|
2022-11-27 20:52:40 +00:00
|
|
|
}
|
2022-11-27 19:03:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t length = 0;
|
2022-12-26 06:28:56 +00:00
|
|
|
char* buf;
|
2022-12-28 06:49:38 +00:00
|
|
|
if (obj.Has("data")) {
|
2022-12-28 23:01:50 +00:00
|
|
|
Napi::Buffer<char> data = obj.Has("data")
|
|
|
|
? obj.Get("data").As<Napi::Buffer<char>>()
|
|
|
|
: Napi::Buffer<char>::New(env, 0);
|
|
|
|
buf = FunctionMap.at(command)(&type, data.Data(), data.Length(),
|
|
|
|
Arguments, &length);
|
2022-12-26 06:28:56 +00:00
|
|
|
} else {
|
|
|
|
buf = NoInputFunctionMap.at(command)(&type, Arguments, &length);
|
|
|
|
}
|
2022-12-28 23:01:50 +00:00
|
|
|
|
|
|
|
vips_error_clear();
|
|
|
|
vips_thread_shutdown();
|
|
|
|
|
|
|
|
result.Set("data", Napi::Buffer<char>::New(
|
|
|
|
env, buf, length,
|
|
|
|
[](Napi::Env env, void* data) { free(data); }));
|
2022-11-27 19:03:07 +00:00
|
|
|
result.Set("type", type);
|
2022-12-28 23:01:50 +00:00
|
|
|
} catch (std::exception const& err) {
|
2022-11-27 19:03:07 +00:00
|
|
|
Napi::Error::New(env, err.what()).ThrowAsJavaScriptException();
|
|
|
|
} catch (...) {
|
|
|
|
Napi::Error::New(env, "Unknown error").ThrowAsJavaScriptException();
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2022-12-28 23:01:50 +00:00
|
|
|
Napi::Object Init(Napi::Env env, Napi::Object exports) {
|
2021-12-31 05:08:06 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
Magick::InitializeMagick("");
|
|
|
|
#endif
|
2022-12-28 23:01:50 +00:00
|
|
|
if (vips_init("")) vips_error_exit(NULL);
|
|
|
|
exports.Set(Napi::String::New(env, "image"),
|
|
|
|
Napi::Function::New(env, ProcessImage)); // new function handler
|
|
|
|
|
|
|
|
Napi::Array arr = Napi::Array::New(env);
|
|
|
|
size_t i = 0;
|
|
|
|
for (auto const& imap : FunctionMap) {
|
|
|
|
Napi::HandleScope scope(env);
|
|
|
|
arr[i] = Napi::String::New(env, imap.first);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
for (auto const& imap : NoInputFunctionMap) {
|
|
|
|
Napi::HandleScope scope(env);
|
|
|
|
arr[i] = Napi::String::New(env, imap.first);
|
|
|
|
i++;
|
|
|
|
}
|
2022-11-27 20:52:40 +00:00
|
|
|
|
2022-12-28 23:01:50 +00:00
|
|
|
exports.Set(Napi::String::New(env, "funcs"), arr);
|
2022-11-27 20:52:40 +00:00
|
|
|
|
2022-12-28 23:01:50 +00:00
|
|
|
return exports;
|
2020-07-12 15:14:39 +00:00
|
|
|
}
|
|
|
|
|
2022-02-12 21:09:59 +00:00
|
|
|
NODE_API_MODULE(addon, Init)
|