@shqld/canvas 3.2.2-rc.1

package/src/Image.h

@@ -0,0 +1,146 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+#include <cairo.h>
+#include "CanvasError.h"
+#include <functional>
+#include <napi.h>
+#include <stdint.h> // node < 7 uses libstdc++ on macOS which lacks complete c++11
+
+#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 Napi::ObjectWrap<Image> {
+  public:
+    char *filename;
+    int width, height;
+    int naturalWidth, naturalHeight;
+    Napi::Env env;
+    static Napi::FunctionReference constructor;
+    static void Initialize(Napi::Env& env, Napi::Object& target);
+    Image(const Napi::CallbackInfo& info);
+    Napi::Value GetComplete(const Napi::CallbackInfo& info);
+    Napi::Value GetWidth(const Napi::CallbackInfo& info);
+    Napi::Value GetHeight(const Napi::CallbackInfo& info);
+    Napi::Value GetNaturalWidth(const Napi::CallbackInfo& info);
+    Napi::Value GetNaturalHeight(const Napi::CallbackInfo& info);
+    Napi::Value GetDataMode(const Napi::CallbackInfo& info);
+    void SetDataMode(const Napi::CallbackInfo& info, const Napi::Value& value);
+    void SetWidth(const Napi::CallbackInfo& info, const Napi::Value& value);
+    void SetHeight(const Napi::CallbackInfo& info, const Napi::Value& value);
+    static Napi::Value GetSource(const Napi::CallbackInfo& info);
+    static void SetSource(const Napi::CallbackInfo& info);
+    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
+    enum Orientation {
+        NORMAL,
+        MIRROR_HORIZ,
+        MIRROR_VERT,
+        ROTATE_180,
+        ROTATE_90_CW,
+        ROTATE_270_CW,
+        MIRROR_HORIZ_AND_ROTATE_90_CW,
+        MIRROR_HORIZ_AND_ROTATE_270_CW
+    };
+    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, Orientation orientation);
+    cairo_status_t decodeJPEGBufferIntoMimeSurface(uint8_t *buf, unsigned len);
+    cairo_status_t assignDataAsMime(uint8_t *data, int len, const char *mime_type);
+
+    class Reader {
+    public:
+      virtual bool hasBytes(unsigned n) const = 0;
+      virtual uint8_t getNext() = 0;
+      virtual void skipBytes(unsigned n) = 0;
+    };
+    Orientation getExifOrientation(Reader& jpeg);
+    void updateDimensionsForOrientation(Orientation orientation);
+    void rotatePixels(uint8_t* pixels, int width, int height, int channels, Orientation orientation);
+#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
+};

package/src/ImageData.cc

@@ -0,0 +1,138 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#include "ImageData.h"
+#include "InstanceData.h"
+
+/*
+ * Initialize ImageData.
+ */
+
+void
+ImageData::Initialize(Napi::Env& env, Napi::Object& exports) {
+  Napi::HandleScope scope(env);
+
+  InstanceData *data = env.GetInstanceData<InstanceData>();
+
+  Napi::Function ctor = DefineClass(env, "ImageData", {
+    InstanceAccessor<&ImageData::GetWidth>("width", napi_default_jsproperty),
+    InstanceAccessor<&ImageData::GetHeight>("height", napi_default_jsproperty)
+  });
+
+  exports.Set("ImageData", ctor);
+  data->ImageDataCtor = Napi::Persistent(ctor);
+}
+
+/*
+ * Initialize a new ImageData object.
+ */
+
+ImageData::ImageData(const Napi::CallbackInfo& info) : Napi::ObjectWrap<ImageData>(info), env(info.Env()) {
+  Napi::TypedArray dataArray;
+  uint32_t width;
+  uint32_t height;
+  uint32_t length;
+
+  if (info[0].IsNumber() && info[1].IsNumber()) {
+    width = info[0].As<Napi::Number>().Uint32Value();
+    if (width == 0) {
+      Napi::RangeError::New(env, "The source width is zero.").ThrowAsJavaScriptException();
+      return;
+    }
+    height = info[1].As<Napi::Number>().Uint32Value();
+    if (height == 0) {
+      Napi::RangeError::New(env, "The source height is zero.").ThrowAsJavaScriptException();
+      return;
+    }
+    if ((uint64_t)width * height > INT32_MAX / 4) {
+      // INT32_MAX is what Firefox limits ImageData to
+      std::string msg = "buffer exceeds " + std::to_string(INT32_MAX) + " bytes";
+      Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+      return;
+    }
+    length = width * height * 4; // ImageData(w, h) constructor assumes 4 BPP; documented.
+
+    dataArray = Napi::Uint8Array::New(env, length, napi_uint8_clamped_array);
+  } else if (
+    info[0].IsTypedArray() &&
+    info[0].As<Napi::TypedArray>().TypedArrayType() == napi_uint8_clamped_array &&
+    info[1].IsNumber()
+  ) {
+    dataArray = info[0].As<Napi::Uint8Array>();
+
+    length = dataArray.ElementLength();
+    if (length == 0) {
+      Napi::RangeError::New(env, "The input data has a zero byte length.").ThrowAsJavaScriptException();
+      return;
+    }
+
+    // Don't assert that the ImageData length is a multiple of four because some
+    // data formats are not 4 BPP.
+
+    width = info[1].As<Napi::Number>().Uint32Value();
+    if (width == 0) {
+      Napi::RangeError::New(env, "The source width is zero.").ThrowAsJavaScriptException();
+      return;
+    }
+
+    // Don't assert that the byte length is a multiple of 4 * width, ditto.
+
+    if (info[2].IsNumber()) { // Explicit height given
+      height = info[2].As<Napi::Number>().Uint32Value();
+    } else { // Calculate height assuming 4 BPP
+      int size = length / 4;
+      height = size / width;
+    }
+  } else if (
+    info[0].IsTypedArray() &&
+    info[0].As<Napi::TypedArray>().TypedArrayType() == napi_uint16_array &&
+    info[1].IsNumber()
+  ) { // Intended for RGB16_565 format
+    dataArray = info[0].As<Napi::TypedArray>();
+
+    length = dataArray.ElementLength();
+    if (length == 0) {
+      Napi::RangeError::New(env, "The input data has a zero byte length.").ThrowAsJavaScriptException();
+      return;
+    }
+
+    width = info[1].As<Napi::Number>().Uint32Value();
+    if (width == 0) {
+      Napi::RangeError::New(env, "The source width is zero.").ThrowAsJavaScriptException();
+      return;
+    }
+
+    if (info[2].IsNumber()) { // Explicit height given
+      height = info[2].As<Napi::Number>().Uint32Value();
+    } else { // Calculate height assuming 2 BPP
+      int size = length / 2;
+      height = size / width;
+    }
+  } else {
+    Napi::TypeError::New(env, "Expected (Uint8ClampedArray, width[, height]), (Uint16Array, width[, height]) or (width, height)").ThrowAsJavaScriptException();
+    return;
+  }
+
+  _width = width;
+  _height = height;
+  _data = dataArray.As<Napi::Uint8Array>().Data();
+
+  info.This().As<Napi::Object>().Set("data", dataArray);
+}
+
+/*
+ * Get width.
+ */
+
+Napi::Value
+ImageData::GetWidth(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(env, width());
+}
+
+/*
+ * Get height.
+ */
+
+Napi::Value
+ImageData::GetHeight(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(env, height());
+}

package/src/ImageData.h

@@ -0,0 +1,26 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+#include <napi.h>
+#include <stdint.h> // node < 7 uses libstdc++ on macOS which lacks complete c++11
+
+class ImageData : public Napi::ObjectWrap<ImageData> {
+  public:
+    static void Initialize(Napi::Env& env, Napi::Object& exports);
+    ImageData(const Napi::CallbackInfo& info);
+    Napi::Value GetWidth(const Napi::CallbackInfo& info);
+    Napi::Value GetHeight(const Napi::CallbackInfo& info);
+
+    inline uint32_t width() { return _width; }
+    inline uint32_t height() { return _height; }
+    inline uint8_t *data() { return _data; }
+
+    Napi::Env env;
+
+  private:
+    uint32_t _width;
+    uint32_t _height;
+    uint8_t *_data;
+
+};

package/src/InstanceData.h

@@ -0,0 +1,12 @@
+#include <napi.h>
+
+struct InstanceData {
+  Napi::FunctionReference CanvasCtor;
+  Napi::FunctionReference CanvasGradientCtor;
+  Napi::FunctionReference DOMMatrixCtor;
+  Napi::FunctionReference ImageCtor;
+  Napi::FunctionReference parseFont;
+  Napi::FunctionReference Context2dCtor;
+  Napi::FunctionReference ImageDataCtor;
+  Napi::FunctionReference CanvasPatternCtor;
+};

package/src/JPEGStream.h

@@ -0,0 +1,157 @@
+#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){
+  closure_destination_mgr *dest = (closure_destination_mgr *) cinfo->dest;
+  Napi::Env env = dest->closure->canvas->Env();
+  Napi::HandleScope scope(env);
+  Napi::AsyncContext async(env, "canvas:empty_closure_output_buffer");
+
+  Napi::Object buf = Napi::Buffer<char>::New(env, (char *)dest->buffer, dest->bufsize);
+
+  // emit "data"
+  dest->closure->cb.MakeCallback(env.Global(), {env.Null(), buf}, 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){
+  closure_destination_mgr *dest = (closure_destination_mgr *) cinfo->dest;
+  Napi::Env env = dest->closure->canvas->Env();
+  Napi::HandleScope scope(env);
+  Napi::AsyncContext async(env, "canvas:term_closure_destination");
+
+  /* emit remaining data */
+  Napi::Object buf = Napi::Buffer<char>::New(env, (char *)dest->buffer, dest->bufsize - dest->pub.free_in_buffer);
+
+  dest->closure->cb.MakeCallback(env.Global(), {env.Null(), buf}, async);
+
+  // emit "end"
+  dest->closure->cb.MakeCallback(env.Global(), {env.Null(), env.Null()}, 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);
+}