@shqld/canvas 2.11.2-rc.1

package/src/Image.h

@@ -0,0 +1,127 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+#include <cairo.h>
+#include "CanvasError.h"
+#include <functional>
+#include <nan.h>
+#include <stdint.h> // node < 7 uses libstdc++ on macOS which lacks complete c++11
+#include <v8.h>
+
+#ifdef HAVE_JPEG
+#include <jpeglib.h>
+#include <jerror.h>
+#endif
+
+#ifdef HAVE_GIF
+#include <gif_lib.h>
+
+  #if GIFLIB_MAJOR > 5 || GIFLIB_MAJOR == 5 && GIFLIB_MINOR >= 1
+    #define GIF_CLOSE_FILE(gif) DGifCloseFile(gif, NULL)
+  #else
+    #define GIF_CLOSE_FILE(gif) DGifCloseFile(gif)
+  #endif
+#endif
+
+#ifdef HAVE_RSVG
+#include <librsvg/rsvg.h>
+  // librsvg <= 2.36.1, identified by undefined macro, needs an extra include
+  #ifndef LIBRSVG_CHECK_VERSION
+  #include <librsvg/rsvg-cairo.h>
+  #endif
+#endif
+
+using JPEGDecodeL = std::function<uint32_t (uint8_t* const src)>;
+
+class Image: public Nan::ObjectWrap {
+  public:
+    char *filename;
+    int width, height;
+    int naturalWidth, naturalHeight;
+    static Nan::Persistent<v8::FunctionTemplate> constructor;
+    static void Initialize(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target);
+    static NAN_METHOD(New);
+    static NAN_GETTER(GetComplete);
+    static NAN_GETTER(GetWidth);
+    static NAN_GETTER(GetHeight);
+    static NAN_GETTER(GetNaturalWidth);
+    static NAN_GETTER(GetNaturalHeight);
+    static NAN_GETTER(GetDataMode);
+    static NAN_SETTER(SetDataMode);
+    static NAN_SETTER(SetWidth);
+    static NAN_SETTER(SetHeight);
+    static NAN_METHOD(GetSource);
+    static NAN_METHOD(SetSource);
+    inline uint8_t *data(){ return cairo_image_surface_get_data(_surface); }
+    inline int stride(){ return cairo_image_surface_get_stride(_surface); }
+    static int isPNG(uint8_t *data);
+    static int isJPEG(uint8_t *data);
+    static int isGIF(uint8_t *data);
+    static int isSVG(uint8_t *data, unsigned len);
+    static int isBMP(uint8_t *data, unsigned len);
+    static cairo_status_t readPNG(void *closure, unsigned char *data, unsigned len);
+    inline int isComplete(){ return COMPLETE == state; }
+    cairo_surface_t *surface();
+    cairo_status_t loadSurface();
+    cairo_status_t loadFromBuffer(uint8_t *buf, unsigned len);
+    cairo_status_t loadPNGFromBuffer(uint8_t *buf);
+    cairo_status_t loadPNG();
+    void clearData();
+#ifdef HAVE_RSVG
+    cairo_status_t loadSVGFromBuffer(uint8_t *buf, unsigned len);
+    cairo_status_t loadSVG(FILE *stream);
+    cairo_status_t renderSVGToSurface();
+#endif
+#ifdef HAVE_GIF
+    cairo_status_t loadGIFFromBuffer(uint8_t *buf, unsigned len);
+    cairo_status_t loadGIF(FILE *stream);
+#endif
+#ifdef HAVE_JPEG
+    cairo_status_t loadJPEGFromBuffer(uint8_t *buf, unsigned len);
+    cairo_status_t loadJPEG(FILE *stream);
+    void jpegToARGB(jpeg_decompress_struct* args, uint8_t* data, uint8_t* src, JPEGDecodeL decode);
+    cairo_status_t decodeJPEGIntoSurface(jpeg_decompress_struct *info);
+    cairo_status_t decodeJPEGBufferIntoMimeSurface(uint8_t *buf, unsigned len);
+    cairo_status_t assignDataAsMime(uint8_t *data, int len, const char *mime_type);
+#endif
+    cairo_status_t loadBMPFromBuffer(uint8_t *buf, unsigned len);
+    cairo_status_t loadBMP(FILE *stream);
+    CanvasError errorInfo;
+    void loaded();
+    cairo_status_t load();
+    Image();
+
+    enum {
+        DEFAULT
+      , LOADING
+      , COMPLETE
+    } state;
+
+    enum data_mode_t {
+        DATA_IMAGE = 1
+      , DATA_MIME = 2
+    } data_mode;
+
+    typedef enum {
+        UNKNOWN
+      , GIF
+      , JPEG
+      , PNG
+      , SVG
+    } type;
+
+    static type extension(const char *filename);
+
+  private:
+    cairo_surface_t *_surface;
+    uint8_t *_data = nullptr;
+    int _data_len;
+#ifdef HAVE_RSVG
+    RsvgHandle *_rsvg;
+    bool _is_svg;
+    int _svg_last_width;
+    int _svg_last_height;
+#endif
+    ~Image();
+};

package/src/ImageData.cc

@@ -0,0 +1,146 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#include "ImageData.h"
+
+using namespace v8;
+
+Nan::Persistent<FunctionTemplate> ImageData::constructor;
+
+/*
+ * Initialize ImageData.
+ */
+
+void
+ImageData::Initialize(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target) {
+  Nan::HandleScope scope;
+
+  // Constructor
+  Local<FunctionTemplate> ctor = Nan::New<FunctionTemplate>(ImageData::New);
+  constructor.Reset(ctor);
+  ctor->InstanceTemplate()->SetInternalFieldCount(1);
+  ctor->SetClassName(Nan::New("ImageData").ToLocalChecked());
+
+  // Prototype
+  Local<ObjectTemplate> proto = ctor->PrototypeTemplate();
+  Nan::SetAccessor(proto, Nan::New("width").ToLocalChecked(), GetWidth);
+  Nan::SetAccessor(proto, Nan::New("height").ToLocalChecked(), GetHeight);
+  Local<Context> ctx = Nan::GetCurrentContext();
+  Nan::Set(target, Nan::New("ImageData").ToLocalChecked(), ctor->GetFunction(ctx).ToLocalChecked());
+}
+
+/*
+ * Initialize a new ImageData object.
+ */
+
+NAN_METHOD(ImageData::New) {
+  if (!info.IsConstructCall()) {
+    return Nan::ThrowTypeError("Class constructors cannot be invoked without 'new'");
+  }
+
+  Local<TypedArray> dataArray;
+  uint32_t width;
+  uint32_t height;
+  int length;
+
+  if (info[0]->IsUint32() && info[1]->IsUint32()) {
+    width = Nan::To<uint32_t>(info[0]).FromMaybe(0);
+    if (width == 0) {
+      Nan::ThrowRangeError("The source width is zero.");
+      return;
+    }
+    height = Nan::To<uint32_t>(info[1]).FromMaybe(0);
+    if (height == 0) {
+      Nan::ThrowRangeError("The source height is zero.");
+      return;
+    }
+    length = width * height * 4; // ImageData(w, h) constructor assumes 4 BPP; documented.
+
+    dataArray = Uint8ClampedArray::New(ArrayBuffer::New(Isolate::GetCurrent(), length), 0, length);
+
+  } else if (info[0]->IsUint8ClampedArray() && info[1]->IsUint32()) {
+    dataArray = info[0].As<Uint8ClampedArray>();
+
+    length = dataArray->Length();
+    if (length == 0) {
+      Nan::ThrowRangeError("The input data has a zero byte length.");
+      return;
+    }
+
+    // Don't assert that the ImageData length is a multiple of four because some
+    // data formats are not 4 BPP.
+
+    width = Nan::To<uint32_t>(info[1]).FromMaybe(0);
+    if (width == 0) {
+      Nan::ThrowRangeError("The source width is zero.");
+      return;
+    }
+
+    // Don't assert that the byte length is a multiple of 4 * width, ditto.
+
+    if (info[2]->IsUint32()) { // Explicit height given
+      height = Nan::To<uint32_t>(info[2]).FromMaybe(0);
+    } else { // Calculate height assuming 4 BPP
+      int size = length / 4;
+      height = size / width;
+    }
+
+  } else if (info[0]->IsUint16Array() && info[1]->IsUint32()) { // Intended for RGB16_565 format
+  dataArray = info[0].As<Uint16Array>();
+
+  length = dataArray->Length();
+  if (length == 0) {
+    Nan::ThrowRangeError("The input data has a zero byte length.");
+    return;
+  }
+
+  width = Nan::To<uint32_t>(info[1]).FromMaybe(0);
+  if (width == 0) {
+    Nan::ThrowRangeError("The source width is zero.");
+    return;
+  }
+
+  if (info[2]->IsUint32()) { // Explicit height given
+    height = Nan::To<uint32_t>(info[2]).FromMaybe(0);
+  } else { // Calculate height assuming 2 BPP
+    int size = length / 2;
+    height = size / width;
+  }
+
+  } else {
+    Nan::ThrowTypeError("Expected (Uint8ClampedArray, width[, height]), (Uint16Array, width[, height]) or (width, height)");
+    return;
+  }
+
+  Nan::TypedArrayContents<uint8_t> dataPtr(dataArray);
+
+  ImageData *imageData = new ImageData(reinterpret_cast<uint8_t*>(*dataPtr), width, height);
+  imageData->Wrap(info.This());
+  Nan::Set(info.This(), Nan::New("data").ToLocalChecked(), dataArray).Check();
+  info.GetReturnValue().Set(info.This());
+}
+
+/*
+ * Get width.
+ */
+
+NAN_GETTER(ImageData::GetWidth) {
+  if (!ImageData::constructor.Get(info.GetIsolate())->HasInstance(info.This())) {
+    Nan::ThrowTypeError("Method ImageData.GetWidth called on incompatible receiver");
+    return;
+  }
+  ImageData *imageData = Nan::ObjectWrap::Unwrap<ImageData>(info.This());
+  info.GetReturnValue().Set(Nan::New<Number>(imageData->width()));
+}
+
+/*
+ * Get height.
+ */
+
+NAN_GETTER(ImageData::GetHeight) {
+  if (!ImageData::constructor.Get(info.GetIsolate())->HasInstance(info.This())) {
+    Nan::ThrowTypeError("Method ImageData.GetHeight called on incompatible receiver");
+    return;
+  }
+  ImageData *imageData = Nan::ObjectWrap::Unwrap<ImageData>(info.This());
+  info.GetReturnValue().Set(Nan::New<Number>(imageData->height()));
+}

package/src/ImageData.h

@@ -0,0 +1,27 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+#include <nan.h>
+#include <stdint.h> // node < 7 uses libstdc++ on macOS which lacks complete c++11
+#include <v8.h>
+
+class ImageData: public Nan::ObjectWrap {
+  public:
+    static Nan::Persistent<v8::FunctionTemplate> constructor;
+    static void Initialize(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target);
+    static NAN_METHOD(New);
+    static NAN_GETTER(GetWidth);
+    static NAN_GETTER(GetHeight);
+
+    inline int width() { return _width; }
+    inline int height() { return _height; }
+    inline uint8_t *data() { return _data; }
+    ImageData(uint8_t *data, int width, int height) : _width(width), _height(height), _data(data) {}
+
+  private:
+    int _width;
+    int _height;
+    uint8_t *_data;
+
+};

package/src/JPEGStream.h

@@ -0,0 +1,167 @@
+#pragma once
+
+#include "closure.h"
+#include <jpeglib.h>
+#include <jerror.h>
+
+/*
+ * Expanded data destination object for closure output,
+ * inspired by IJG's jdatadst.c
+ */
+
+struct closure_destination_mgr {
+  jpeg_destination_mgr pub;
+  JpegClosure* closure;
+  JOCTET *buffer;
+  int bufsize;
+};
+
+void
+init_closure_destination(j_compress_ptr cinfo){
+  // we really don't have to do anything here
+}
+
+boolean
+empty_closure_output_buffer(j_compress_ptr cinfo){
+  Nan::HandleScope scope;
+  Nan::AsyncResource async("canvas:empty_closure_output_buffer");
+  closure_destination_mgr *dest = (closure_destination_mgr *) cinfo->dest;
+
+  v8::Local<v8::Object> buf = Nan::NewBuffer((char *)dest->buffer, dest->bufsize).ToLocalChecked();
+
+  // emit "data"
+  v8::Local<v8::Value> argv[2] = {
+      Nan::Null()
+    , buf
+  };
+  dest->closure->cb.Call(sizeof argv / sizeof *argv, argv, &async);
+
+  dest->buffer = (JOCTET *)malloc(dest->bufsize);
+  cinfo->dest->next_output_byte = dest->buffer;
+  cinfo->dest->free_in_buffer = dest->bufsize;
+  return true;
+}
+
+void
+term_closure_destination(j_compress_ptr cinfo){
+  Nan::HandleScope scope;
+  Nan::AsyncResource async("canvas:term_closure_destination");
+  closure_destination_mgr *dest = (closure_destination_mgr *) cinfo->dest;
+
+  /* emit remaining data */
+  v8::Local<v8::Object> buf = Nan::NewBuffer((char *)dest->buffer, dest->bufsize - dest->pub.free_in_buffer).ToLocalChecked();
+
+  v8::Local<v8::Value> data_argv[2] = {
+      Nan::Null()
+    , buf
+  };
+  dest->closure->cb.Call(sizeof data_argv / sizeof *data_argv, data_argv, &async);
+
+  // emit "end"
+  v8::Local<v8::Value> end_argv[2] = {
+      Nan::Null()
+    , Nan::Null()
+  };
+  dest->closure->cb.Call(sizeof end_argv / sizeof *end_argv, end_argv, &async);
+}
+
+void
+jpeg_closure_dest(j_compress_ptr cinfo, JpegClosure* closure, int bufsize){
+  closure_destination_mgr * dest;
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same buffer without re-executing jpeg_mem_dest.
+   */
+  if (cinfo->dest == NULL) {  /* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+         sizeof(closure_destination_mgr));
+  }
+
+  dest = (closure_destination_mgr *) cinfo->dest;
+
+  cinfo->dest->init_destination = &init_closure_destination;
+  cinfo->dest->empty_output_buffer = &empty_closure_output_buffer;
+  cinfo->dest->term_destination = &term_closure_destination;
+
+  dest->closure = closure;
+  dest->bufsize = bufsize;
+  dest->buffer = (JOCTET *)malloc(bufsize);
+
+  cinfo->dest->next_output_byte = dest->buffer;
+  cinfo->dest->free_in_buffer = dest->bufsize;
+}
+
+void encode_jpeg(jpeg_compress_struct cinfo, cairo_surface_t *surface, int quality, bool progressive, int chromaHSampFactor, int chromaVSampFactor) {
+  int w = cairo_image_surface_get_width(surface);
+  int h = cairo_image_surface_get_height(surface);
+
+  cinfo.in_color_space = JCS_RGB;
+  cinfo.input_components = 3;
+  cinfo.image_width = w;
+  cinfo.image_height = h;
+  jpeg_set_defaults(&cinfo);
+  if (progressive)
+    jpeg_simple_progression(&cinfo);
+  jpeg_set_quality(&cinfo, quality, (quality < 25) ? 0 : 1);
+  cinfo.comp_info[0].h_samp_factor = chromaHSampFactor;
+  cinfo.comp_info[0].v_samp_factor = chromaVSampFactor;
+
+  JSAMPROW slr;
+  jpeg_start_compress(&cinfo, TRUE);
+  unsigned char *dst;
+  unsigned int *src = (unsigned int *)cairo_image_surface_get_data(surface);
+  int sl = 0;
+  dst = (unsigned char *)malloc(w * 3);
+  while (sl < h) {
+    unsigned char *dp = dst;
+    int x = 0;
+    while (x < w) {
+      dp[0] = (*src >> 16) & 255;
+      dp[1] = (*src >> 8) & 255;
+      dp[2] = *src & 255;
+      src++;
+      dp += 3;
+      x++;
+    }
+    slr = dst;
+    jpeg_write_scanlines(&cinfo, &slr, 1);
+    sl++;
+  }
+  free(dst);
+  jpeg_finish_compress(&cinfo);
+  jpeg_destroy_compress(&cinfo);
+}
+
+void
+write_to_jpeg_stream(cairo_surface_t *surface, int bufsize, JpegClosure* closure) {
+  jpeg_compress_struct cinfo;
+  jpeg_error_mgr jerr;
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_compress(&cinfo);
+  jpeg_closure_dest(&cinfo, closure, bufsize);
+  encode_jpeg(
+    cinfo,
+    surface,
+    closure->quality,
+    closure->progressive,
+    closure->chromaSubsampling,
+    closure->chromaSubsampling);
+}
+
+void
+write_to_jpeg_buffer(cairo_surface_t* surface, JpegClosure* closure) {
+  jpeg_compress_struct cinfo;
+  jpeg_error_mgr jerr;
+  cinfo.err = jpeg_std_error(&jerr);
+  jpeg_create_compress(&cinfo);
+  cinfo.client_data = closure;
+  cinfo.dest = closure->jpeg_dest_mgr;
+  encode_jpeg(
+    cinfo,
+    surface,
+    closure->quality,
+    closure->progressive,
+    closure->chromaSubsampling,
+    closure->chromaSubsampling);
+}