InstanceData *data = env.GetInstanceData<InstanceData>();

Napi::HandleScope scope(env);

Napi::Function ctor = DefineClass(env, "Image", {

InstanceAccessor<&Image::GetComplete>("complete", napi_default_jsproperty),

InstanceAccessor<&Image::GetWidth, &Image::SetWidth>("width", napi_default_jsproperty),

InstanceAccessor<&Image::GetHeight, &Image::SetHeight>("height", napi_default_jsproperty),

InstanceAccessor<&Image::GetNaturalWidth>("naturalWidth", napi_default_jsproperty),

InstanceAccessor<&Image::GetNaturalHeight>("naturalHeight", napi_default_jsproperty),

InstanceAccessor<&Image::GetDataMode, &Image::SetDataMode>("dataMode", napi_default_jsproperty),

StaticValue("MODE_IMAGE", Napi::Number::New(env, DATA_IMAGE), napi_default_jsproperty),

StaticValue("MODE_MIME", Napi::Number::New(env, DATA_MIME), napi_default_jsproperty)

});

// Used internally in lib/image.js

exports.Set("GetSource", Napi::Function::New(env, &GetSource));

exports.Set("SetSource", Napi::Function::New(env, &SetSource));

data->ImageCtor = Napi::Persistent(ctor);

exports.Set("Image", ctor);

data_mode = DATA_IMAGE;

info.This().ToObject().Unwrap().Set("onload", env.Null());

info.This().ToObject().Unwrap().Set("onerror", env.Null());

filename = NULL;

_data = nullptr;

_data_len = 0;

_surface = NULL;

width = height = 0;

naturalWidth = naturalHeight = 0;

state = DEFAULT;

#ifdef HAVE_RSVG

_rsvg = NULL;

_is_svg = false;

_svg_last_width = _svg_last_height = 0;

#endif

if (value.IsNumber()) {

int mode = value.As<Napi::Number>().Uint32Value();

data_mode = (data_mode_t) mode;

}

if (value.IsNumber()) {

width = value.As<Napi::Number>().Uint32Value();

}

if (value.IsNumber()) {

height = value.As<Napi::Number>().Uint32Value();

}

Napi::Env env = info.Env();

Image *img = Image::Unwrap(info.This().As<Napi::Object>());

return Napi::String::New(env, img->filename ? img->filename : "");

if (_surface) {

cairo_surface_destroy(_surface);

Napi::MemoryManagement::AdjustExternalMemory(env, -_data_len);

_data_len = 0;

_surface = NULL;

}

delete[] _data;

_data = nullptr;

free(filename);

filename = NULL;

#ifdef HAVE_RSVG

if (_rsvg != NULL) {

g_object_unref(_rsvg);

_rsvg = NULL;

}

#endif

width = height = 0;

naturalWidth = naturalHeight = 0;

state = DEFAULT;

Napi::Env env = info.Env();

Napi::Object This = info.This().As<Napi::Object>();

Image *img = Image::Unwrap(This);

cairo_status_t status = CAIRO_STATUS_READ_ERROR;

Napi::Value value = info[0];

img->clearData();

// Clear errno in case some unrelated previous syscall failed

errno = 0;

// url string

if (value.IsString()) {

std::string src = value.As<Napi::String>().Utf8Value();

if (img->filename) free(img->filename);

img->filename = strdup(src.c_str());

status = img->load();

// Buffer

} else if (value.IsBuffer()) {

uint8_t *buf = value.As<Napi::Buffer<uint8_t>>().Data();

unsigned len = value.As<Napi::Buffer<uint8_t>>().Length();

status = img->loadFromBuffer(buf, len);

}

if (status) {

Napi::Value onerrorFn;

if (This.Get("onerror").UnwrapTo(&onerrorFn) && onerrorFn.IsFunction()) {

Napi::Error arg;

if (img->errorInfo.empty()) {

arg = Napi::Error::New(env, Napi::String::New(env, cairo_status_to_string(status)));

} else {

arg = img->errorInfo.toError(env);

}

onerrorFn.As<Napi::Function>().Call({ arg.Value() });

}

} else {

img->loaded();

Napi::Value onloadFn;

if (This.Get("onload").UnwrapTo(&onloadFn) && onloadFn.IsFunction()) {

onloadFn.As<Napi::Function>().Call({});

}

}

uint8_t data[4] = {0};

memcpy(data, buf, (len < 4 ? len : 4) * sizeof(uint8_t));

if (isPNG(data)) return loadPNGFromBuffer(buf);

if (isGIF(data)) {

#ifdef HAVE_GIF

return loadGIFFromBuffer(buf, len);

#else

this->errorInfo.set("node-canvas was built without GIF support");

return CAIRO_STATUS_READ_ERROR;

#endif

}

if (isJPEG(data)) {

#ifdef HAVE_JPEG

if (DATA_IMAGE == data_mode) return loadJPEGFromBuffer(buf, len);

if (DATA_MIME == data_mode) return decodeJPEGBufferIntoMimeSurface(buf, len);

if ((DATA_IMAGE | DATA_MIME) == data_mode) {

cairo_status_t status;

status = loadJPEGFromBuffer(buf, len);

if (status) return status;

return assignDataAsMime(buf, len, CAIRO_MIME_TYPE_JPEG);

}

#else // HAVE_JPEG

this->errorInfo.set("node-canvas was built without JPEG support");

return CAIRO_STATUS_READ_ERROR;

#endif

}

// confirm svg using first 1000 chars

// if a very long comment precedes the root <svg> tag, isSVG returns false

unsigned head_len = (len < 1000 ? len : 1000);

if (isSVG(buf, head_len)) {

#ifdef HAVE_RSVG

return loadSVGFromBuffer(buf, len);

#else

this->errorInfo.set("node-canvas was built without SVG support");

return CAIRO_STATUS_READ_ERROR;

#endif

}

if (isBMP(buf, len))

return loadBMPFromBuffer(buf, len);

this->errorInfo.set("Unsupported image type");

return CAIRO_STATUS_READ_ERROR;

read_closure_t closure;

closure.len = 0;

closure.buf = buf;

closure.env = &env;

_surface = cairo_image_surface_create_from_png_stream(readPNG, &closure);

cairo_status_t status = cairo_surface_status(_surface);

if (status) return status;

return CAIRO_STATUS_SUCCESS;

read_closure_t *closure = (read_closure_t *) c;

memcpy(data, closure->buf + closure->len, len);

closure->len += len;

return CAIRO_STATUS_SUCCESS;

if (LOADING != state) {

state = LOADING;

return loadSurface();

}

return CAIRO_STATUS_READ_ERROR;

Napi::HandleScope scope(env);

state = COMPLETE;

width = naturalWidth = cairo_image_surface_get_width(_surface);

height = naturalHeight = cairo_image_surface_get_height(_surface);

_data_len = naturalHeight * cairo_image_surface_get_stride(_surface);

Napi::MemoryManagement::AdjustExternalMemory(env, _data_len);

FILE *stream = fopen(filename, "rb");

if (!stream) {

this->errorInfo.set(NULL, "fopen", errno, filename);

return CAIRO_STATUS_READ_ERROR;

}

uint8_t buf[5];

if (1 != fread(&buf, 5, 1, stream)) {

fclose(stream);

return CAIRO_STATUS_READ_ERROR;

}

rewind(stream);

// png

if (isPNG(buf)) {

fclose(stream);

return loadPNG();

}

if (isGIF(buf)) {

#ifdef HAVE_GIF

return loadGIF(stream);

#else

this->errorInfo.set("node-canvas was built without GIF support");

return CAIRO_STATUS_READ_ERROR;

#endif

}

if (isJPEG(buf)) {

#ifdef HAVE_JPEG

return loadJPEG(stream);

#else

this->errorInfo.set("node-canvas was built without JPEG support");

return CAIRO_STATUS_READ_ERROR;

#endif

}

// confirm svg using first 1000 chars

// if a very long comment precedes the root <svg> tag, isSVG returns false

uint8_t head[1000] = {0};

fseek(stream, 0 , SEEK_END);

long len = ftell(stream);

unsigned head_len = (len < 1000 ? len : 1000);

unsigned head_size = head_len * sizeof(uint8_t);

rewind(stream);

if (head_size != fread(&head, 1, head_size, stream)) {

fclose(stream);

return CAIRO_STATUS_READ_ERROR;

}

rewind(stream);

if (isSVG(head, head_len)) {

#ifdef HAVE_RSVG

return loadSVG(stream);

#else

this->errorInfo.set("node-canvas was built without SVG support");

return CAIRO_STATUS_READ_ERROR;

#endif

}

if (isBMP(buf, 2))

return loadBMP(stream);

fclose(stream);

this->errorInfo.set("Unsupported image type");

return CAIRO_STATUS_READ_ERROR;

ExtensionBlock *ext = gif->SavedImages[frame].ExtensionBlocks;

int len = gif->SavedImages[frame].ExtensionBlockCount;

for (int x = 0; x < len; ++x, ++ext) {

if ((ext->Function == GRAPHICS_EXT_FUNC_CODE) && (ext->Bytes[0] & 1)) {

return ext->Bytes[3] == 0 ? 0 : (uint8_t) ext->Bytes[3];

}

}

return -1;

gif_data_t *data = (gif_data_t *) gif->UserData;

if ((data->pos + len) > data->len) len = data->len - data->pos;

memcpy(buf, data->pos + data->buf, len);

data->pos += len;

return len;

struct stat s;

int fd = fileno(stream);

// stat

if (fstat(fd, &s) < 0) {

fclose(stream);

return CAIRO_STATUS_READ_ERROR;

}

uint8_t *buf = (uint8_t *) malloc(s.st_size);

if (!buf) {

fclose(stream);

this->errorInfo.set(NULL, "malloc", errno);

return CAIRO_STATUS_NO_MEMORY;

}

size_t read = fread(buf, s.st_size, 1, stream);

fclose(stream);

cairo_status_t result = CAIRO_STATUS_READ_ERROR;

if (1 == read) result = loadGIFFromBuffer(buf, s.st_size);

free(buf);

return result;

int i = 0;

GifFileType* gif;

gif_data_t gifd = { buf, len, 0 };

#if GIFLIB_MAJOR >= 5

int errorcode;

if ((gif = DGifOpen((void*) &gifd, read_gif_from_memory, &errorcode)) == NULL)

return CAIRO_STATUS_READ_ERROR;

#else

if ((gif = DGifOpen((void*) &gifd, read_gif_from_memory)) == NULL)

return CAIRO_STATUS_READ_ERROR;

#endif

if (GIF_OK != DGifSlurp(gif)) {

GIF_CLOSE_FILE(gif);

return CAIRO_STATUS_READ_ERROR;

}

if (gif->SWidth > canvas_max_side || gif->SHeight > canvas_max_side) {

GIF_CLOSE_FILE(gif);

return CAIRO_STATUS_INVALID_SIZE;

}

width = naturalWidth = gif->SWidth;

height = naturalHeight = gif->SHeight;

uint8_t *data = new uint8_t[naturalWidth * naturalHeight * 4];

if (!data) {

GIF_CLOSE_FILE(gif);

this->errorInfo.set(NULL, "malloc", errno);

return CAIRO_STATUS_NO_MEMORY;

}

GifImageDesc *img = &gif->SavedImages[i].ImageDesc;

// local colormap takes precedence over global

ColorMapObject *colormap = img->ColorMap

? img->ColorMap

: gif->SColorMap;

if (colormap == nullptr) {

GIF_CLOSE_FILE(gif);

return CAIRO_STATUS_READ_ERROR;

}

int bgColor = 0;

int alphaColor = get_gif_transparent_color(gif, i);

if (gif->SColorMap) bgColor = (uint8_t) gif->SBackGroundColor;

else if(alphaColor >= 0) bgColor = alphaColor;

uint8_t *src_data = (uint8_t*) gif->SavedImages[i].RasterBits;

uint32_t *dst_data = (uint32_t*) data;

if (!gif->Image.Interlace) {

if (naturalWidth == img->Width && naturalHeight == img->Height) {

for (int y = 0; y < naturalHeight; ++y) {

for (int x = 0; x < naturalWidth; ++x) {

*dst_data = ((*src_data == alphaColor) ? 0 : 255) << 24

| colormap->Colors[*src_data].Red << 16

| colormap->Colors[*src_data].Green << 8

| colormap->Colors[*src_data].Blue;

dst_data++;

src_data++;

}

}

} else {

// Image does not take up whole "screen" so we need to fill-in the background

int bottom = img->Top + img->Height;

int right = img->Left + img->Width;

uint32_t bgPixel =

((bgColor == alphaColor) ? 0 : 255) << 24

| colormap->Colors[bgColor].Red << 16

| colormap->Colors[bgColor].Green << 8

| colormap->Colors[bgColor].Blue;

for (int y = 0; y < naturalHeight; ++y) {

for (int x = 0; x < naturalWidth; ++x) {

if (y < img->Top || y >= bottom || x < img->Left || x >= right) {

*dst_data = bgPixel;

dst_data++;

} else {

*dst_data = ((*src_data == alphaColor) ? 0 : 255) << 24

| colormap->Colors[*src_data].Red << 16

| colormap->Colors[*src_data].Green << 8

| colormap->Colors[*src_data].Blue;

dst_data++;

src_data++;

}

}

}

}

} else {

// Image is interlaced so that it streams nice over 14.4k and 28.8k modems :)

// We first load in 1/8 of the image, followed by another 1/8, followed by

// 1/4 and finally the remaining 1/2.

int ioffs[] = { 0, 4, 2, 1 };

int ijumps[] = { 8, 8, 4, 2 };

uint8_t *src_ptr = src_data;

uint32_t *dst_ptr;

for(int z = 0; z < 4; z++) {

for(int y = ioffs[z]; y < naturalHeight; y += ijumps[z]) {

dst_ptr = dst_data + naturalWidth * y;

for(int x = 0; x < naturalWidth; ++x) {

*dst_ptr = ((*src_ptr == alphaColor) ? 0 : 255) << 24

| (colormap->Colors[*src_ptr].Red) << 16

| (colormap->Colors[*src_ptr].Green) << 8

| (colormap->Colors[*src_ptr].Blue);

dst_ptr++;

src_ptr++;

}

}

}

}

GIF_CLOSE_FILE(gif);

// New image surface

_surface = cairo_image_surface_create_for_data(

data

, CAIRO_FORMAT_ARGB32

, naturalWidth

, naturalHeight

, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, naturalWidth));

cairo_status_t status = cairo_surface_status(_surface);

if (status) {

delete[] data;

return status;

}

_data = data;

return CAIRO_STATUS_SUCCESS;

struct jpeg_source_mgr* src = (struct jpeg_source_mgr*) cinfo->src;

if (num_bytes > 0) {

src->next_input_byte += (size_t) num_bytes;

src->bytes_in_buffer -= (size_t) num_bytes;

}

struct jpeg_source_mgr* src;

if (cinfo->src == NULL) {

cinfo->src = (struct jpeg_source_mgr *)

(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,

sizeof(struct jpeg_source_mgr));

}

src = (struct jpeg_source_mgr*) cinfo->src;

src->init_source = init_source;

src->fill_input_buffer = fill_input_buffer;

src->skip_input_data = skip_input_data;

src->resync_to_restart = jpeg_resync_to_restart; /* use default method */

src->term_source = term_source;

src->bytes_in_buffer = nbytes;

src->next_input_byte = (JOCTET*)buffer;

BufferReader(uint8_t* buf, unsigned len) : _buf(buf), _len(len), _idx(0) {}

bool hasBytes(unsigned n) const override { return (_idx + n - 1 < _len); }

uint8_t getNext() override {

return _buf[_idx++];

}

void skipBytes(unsigned n) override { _idx += n; }

uint8_t* _buf; // we do not own this

unsigned _len;

unsigned _idx;

StreamReader(FILE *stream) : _stream(stream), _len(0), _idx(0) {

fseek(_stream, 0, SEEK_END);

_len = ftell(_stream);

fseek(_stream, 0, SEEK_SET);

}

bool hasBytes(unsigned n) const override { return (_idx + n - 1 < _len); }

uint8_t getNext() override {

++_idx;

return getc(_stream);

}

void skipBytes(unsigned n) override {

_idx += n;

fseek(_stream, _idx, SEEK_SET);

}

FILE* _stream;

unsigned _len;

unsigned _idx;

int stride = naturalWidth * 4;

for (int y = 0; y < naturalHeight; ++y) {

jpeg_read_scanlines(args, &src, 1);

uint32_t *row = (uint32_t*)(data + stride * y);

for (int x = 0; x < naturalWidth; ++x) {

int bx = args->output_components * x;

row[x] = decode(src + bx);

}

}

const int channels = 4;

cairo_status_t status = CAIRO_STATUS_SUCCESS;

uint8_t *data = new uint8_t[naturalWidth * naturalHeight * channels];

if (!data) {

jpeg_abort_decompress(args);

jpeg_destroy_decompress(args);

this->errorInfo.set(NULL, "malloc", errno);

return CAIRO_STATUS_NO_MEMORY;

}

uint8_t *src = new uint8_t[naturalWidth * args->output_components];

if (!src) {

free(data);

jpeg_abort_decompress(args);

jpeg_destroy_decompress(args);

this->errorInfo.set(NULL, "malloc", errno);

return CAIRO_STATUS_NO_MEMORY;

}

// These are the three main cases to handle. libjpeg converts YCCK to CMYK

// and YCbCr to RGB by default.

switch (args->out_color_space) {

case JCS_CMYK:

jpegToARGB(args, data, src, [](uint8_t const* src) {

uint16_t k = static_cast<uint16_t>(src[3]);

uint8_t r = k * src[0] / 255;

uint8_t g = k * src[1] / 255;

uint8_t b = k * src[2] / 255;

return 255 << 24 | r << 16 | g << 8 | b;

});

break;

case JCS_RGB:

jpegToARGB(args, data, src, [](uint8_t const* src) {

uint8_t r = src[0], g = src[1], b = src[2];

return 255 << 24 | r << 16 | g << 8 | b;

});

break;

case JCS_GRAYSCALE:

jpegToARGB(args, data, src, [](uint8_t const* src) {

uint8_t v = src[0];

return 255 << 24 | v << 16 | v << 8 | v;

});

break;

default:

this->errorInfo.set("Unsupported JPEG encoding");

status = CAIRO_STATUS_READ_ERROR;

break;

}

updateDimensionsForOrientation(orientation);

if (!status) {

_surface = cairo_image_surface_create_for_data(

data

, CAIRO_FORMAT_ARGB32

, naturalWidth

, naturalHeight

, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, naturalWidth));

}

jpeg_finish_decompress(args);

jpeg_destroy_decompress(args);

status = cairo_surface_status(_surface);

rotatePixels(data, naturalWidth, naturalHeight, channels, orientation);

delete[] src;

if (status) {

delete[] data;

return status;

}

_data = data;

return CAIRO_STATUS_SUCCESS;

canvas_jpeg_error_mgr *cjerr = static_cast<canvas_jpeg_error_mgr*>(cinfo->err);

cjerr->output_message(cinfo);

// Return control to the setjmp point

longjmp(cjerr->setjmp_buffer, 1);

canvas_jpeg_error_mgr *cjerr = static_cast<canvas_jpeg_error_mgr*>(cinfo->err);

char buff[JMSG_LENGTH_MAX];

cjerr->format_message(cinfo, buff);

// (Only the last message will be returned to JS land.)

cjerr->image->errorInfo.set(buff);

// TODO: remove this duplicate logic

// JPEG setup

struct jpeg_decompress_struct args;

struct canvas_jpeg_error_mgr err;

err.image = this;

args.err = jpeg_std_error(&err);

args.err->error_exit = canvas_jpeg_error_exit;

args.err->output_message = canvas_jpeg_output_message;

// Establish the setjmp return context for canvas_jpeg_error_exit to use

if (setjmp(err.setjmp_buffer)) {

// If we get here, the JPEG code has signaled an error.

// We need to clean up the JPEG object, close the input file, and return.

jpeg_destroy_decompress(&args);

return CAIRO_STATUS_READ_ERROR;

}

jpeg_create_decompress(&args);

jpeg_mem_src(&args, buf, len);

jpeg_read_header(&args, 1);

jpeg_start_decompress(&args);

width = naturalWidth = args.output_width;

height = naturalHeight = args.output_height;

// Data alloc

// 8 pixels per byte using Alpha Channel format to reduce memory requirement.

int buf_size = naturalHeight * cairo_format_stride_for_width(CAIRO_FORMAT_A1, naturalWidth);

uint8_t *data = new uint8_t[buf_size];

if (!data) {

this->errorInfo.set(NULL, "malloc", errno);

return CAIRO_STATUS_NO_MEMORY;

}

BufferReader reader(buf, len);

Orientation orientation = getExifOrientation(reader);

updateDimensionsForOrientation(orientation);

// New image surface

_surface = cairo_image_surface_create_for_data(

data

, CAIRO_FORMAT_A1

, naturalWidth

, naturalHeight

, cairo_format_stride_for_width(CAIRO_FORMAT_A1, naturalWidth));

// Cleanup

jpeg_abort_decompress(&args);

jpeg_destroy_decompress(&args);

cairo_status_t status = cairo_surface_status(_surface);

if (status) {

delete[] data;

return status;

}

rotatePixels(data, naturalWidth, naturalHeight, 1, orientation);

_data = data;

return assignDataAsMime(buf, len, CAIRO_MIME_TYPE_JPEG);