Support for reading and writing PNG metadata

README.md

@@ -36,6 +36,7 @@
     0. [Opacify](#opacify)
     0. [Paste](#paste)
     0. [Set pixel](#set-pixel)
+    0. [Set metadata](#set-metadata)
   0. [Getters](#getters)
     0. [Width](#width)
     0. [Height](#height)
@@ -47,6 +48,7 @@
       0. [PNG](#png)
       0. [GIF](#gif)
     0. [Write to file](#write-to-file)
+    0. [Get metadata](#get-metadata)
   0. [Batch operations](#batch-operations)
 0. [Copyrights](#copyrights)
 
@@ -554,6 +556,15 @@ Set the color of a pixel.
 0. Extra caution is required when using this method in batch mode, as the
   dimensions of the image may change by the time this operation is called.
 
+#### Set metadata
+
+Set the metadata in an image. This is currently only supported for PNG files.
+Sets a tEXt chunk with the key `lwip_data` and comment as the given string.
+
+`image.setMetadata(metadata)`
+
+0. `metadata {String}`: a string of arbitrary length.
+
 ### Getters
 
 #### Width
@@ -685,6 +696,14 @@ Write encoded binary image data directly to a file.
 0. `params {Object}`: **Optional** Format-specific parameters.
 0. `callback {Function(err)}`
 
+#### Get Metadata
+
+Get the textual metadata from an image. This is currently only supported for
+tEXt chunks in PNG images, and will get the first tEXt chunk found with the key
+`lwip_data`.
+
+`image.getMetadata()`
+
 ### Batch operations
 
 Each of the [image operations](#image-operations) above can be done as part of

lib/Image.js

@@ -2,10 +2,11 @@
 
     var lwip_image = require('../build/Release/lwip_image');
 
-    function Image(pixelsBuf, width, height, trans) {
+    function Image(pixelsBuf, width, height, trans, metadata) {
         this.__lwip = new lwip_image.LwipImage(pixelsBuf, width, height);
         this.__locked = false;
         this.__trans = trans;
+        this.__metadata = metadata;
     }
 
     // EXPORTS

lib/ImagePrototypeInit.js

@@ -47,6 +47,19 @@
         this.__locked = false;
     };
 
+    Image.prototype.getMetadata = function() {
+        if (!this.__metadata || this.__metadata === "") {
+            return null;
+        } else {
+            return this.__metadata;
+        }
+    };
+
+    Image.prototype.setMetadata = function(data) {
+        this.__metadata = data;
+        return data;
+    };
+
     Image.prototype.width = function() {
         return this.__lwip.width();
     };
@@ -550,6 +563,11 @@
                             encoderCb
                         );
                     } else if (type === 'png') {
+                        var metadata = that.__metadata;
+                        if (!metadata) {
+                            metadata = "";
+                        }
+
                         util.normalizePngParams(params);
                         return encoder.png(
                             that.__lwip.buffer(),
@@ -558,6 +576,7 @@
                             params.compression,
                             params.interlaced,
                             params.transparency === 'auto' ? that.__trans : params.transparency,
+                            metadata,
                             encoderCb
                         );
                     } else if (type === 'gif') {

lib/obtain.js

@@ -28,8 +28,8 @@
                 opener = getOpener(type);
                 fs.readFile(source, function(err, imbuff) {
                     if (err) return callback(err);
-                    opener(imbuff, function(err, pixelsBuf, width, height, channels, trans) {
-                        callback(err, err ? null : new Image(pixelsBuf, width, height, trans));
+                    opener(imbuff, function(err, pixelsBuf, width, height, channels, trans, metadata) {
+                        callback(err, err ? null : new Image(pixelsBuf, width, height, trans, metadata));
                     });
                 });
             } else if (source instanceof Buffer) {
@@ -44,8 +44,8 @@
                 } else if (typeof type === 'string') {
                     // it's an encoded image
                     opener = getOpener(type);
-                    opener(source, function(err, pixelsBuf, width, height, channels, trans) {
-                        callback(err, err ? null : new Image(pixelsBuf, width, height, trans));
+                    opener(source, function(err, pixelsBuf, width, height, channels, trans, metadata) {
+                        callback(err, err ? null : new Image(pixelsBuf, width, height, trans, metadata));
                     });
                 } else throw Error('Invalid type');
             } else throw Error("Invalid source");

src/decoder/buffer_worker.cpp

@@ -1,11 +1,12 @@
 #include "decoder.h"
+#include <iostream>
 
 DecodeBufferWorker::DecodeBufferWorker(
     NanCallback * callback,
     Local<Object> & buff,
     buf_dec_f_t decoder
 ): NanAsyncWorker(callback), _decoder(decoder), _pixbuf(NULL), _width(0),
-    _height(0), _channels(0), _trans(false) {
+    _height(0), _channels(0), _trans(false), _metadata("") {
     SaveToPersistent("buff", buff); // make sure buff isn't GC'ed
     _buffer = Buffer::Data(buff);
     _buffsize = Buffer::Length(buff);
@@ -16,7 +17,10 @@ DecodeBufferWorker::~DecodeBufferWorker() {}
 void DecodeBufferWorker::Execute () {
     CImg<unsigned char> * img = NULL;
     string err;
-    err = _decoder(_buffer, _buffsize, &img);
+    char * metadata = NULL;
+
+    err = _decoder(_buffer, _buffsize, &img, &metadata);
+
     if (img == NULL) {
         SetErrorMessage(err.c_str());
         return;
@@ -33,6 +37,8 @@ void DecodeBufferWorker::Execute () {
     _width = img->width();
     _height = img->height();
     _channels = 4;
+    _metadata = metadata;
+
     delete img;
     return;
 }
@@ -48,7 +54,9 @@ void DecodeBufferWorker::HandleOKCallback () {
         NanNew<Number>(_width),
         NanNew<Number>(_height),
         NanNew<Number>(_channels),
-        NanNew<Boolean>(_trans)
+        NanNew<Boolean>(_trans),
+        NanNew<String>(_metadata)
     };
-    callback->Call(6, argv);
+
+    callback->Call(7, argv);
 }

src/decoder/decoder.h

@@ -25,7 +25,7 @@ using namespace v8;
 using namespace node;
 using namespace std;
 
-typedef string (* buf_dec_f_t)(char *, size_t, CImg<unsigned char> **);
+typedef string (* buf_dec_f_t)(char *, size_t, CImg<unsigned char> **, char **);
 
 class DecodeBufferWorker : public NanAsyncWorker {
 public:
@@ -46,6 +46,7 @@ class DecodeBufferWorker : public NanAsyncWorker {
     size_t _height;
     int _channels;
     bool _trans; // transparency
+    char * _metadata;
 };
 
 typedef struct {
@@ -77,9 +78,9 @@ inline void lwip_jpeg_error_exit (j_common_ptr cinfo) {
  */
 string toRGBA(CImg<unsigned char> ** img);
 
-string decode_jpeg_buffer(char * buffer, size_t size, CImg<unsigned char> ** img);
-string decode_png_buffer(char * buffer, size_t size, CImg<unsigned char> ** img);
-string decode_gif_buffer(char * buffer, size_t size, CImg<unsigned char> ** img);
+string decode_jpeg_buffer(char * buffer, size_t size, CImg<unsigned char> ** img, char ** metadata);
+string decode_png_buffer(char * buffer, size_t size, CImg<unsigned char> ** img, char ** metadata);
+string decode_gif_buffer(char * buffer, size_t size, CImg<unsigned char> ** img, char ** metadata);
 
 void pngReadCB(png_structp png_ptr, png_bytep data, png_size_t length);
 int gifReadCB(GifFileType * gif, GifByteType * buf, int length);

src/decoder/gif_decoder.cpp

@@ -4,7 +4,7 @@
 #define ALPHA_OPAQUE 255
 #define C_TRANS 0
 
-string decode_gif_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg) {
+string decode_gif_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg, char ** metadata) {
 
     gifReadCbData buffinf = {(unsigned char *) buffer, size, 0};
     GifFileType * gif = NULL;
@@ -70,6 +70,10 @@ string decode_gif_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg
         return GifErrorString(errcode);
     }
 
+    // TODO: implement getting metadata from GIFs; this is a placeholder
+    *metadata = (char *)malloc(sizeof(char));
+    *metadata[0] = '\0';
+
     return "";
 }
 

src/decoder/jpeg_decoder.cpp

@@ -1,6 +1,6 @@
 #include "decoder.h"
 
-string decode_jpeg_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg) {
+string decode_jpeg_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg, char ** metadata) {
     struct jpeg_decompress_struct cinfo;
     struct lwip_jpeg_error_mgr jerr;
 
@@ -53,5 +53,9 @@ string decode_jpeg_buffer(char * buffer, size_t size, CImg<unsigned char> ** cim
     jpeg_finish_decompress(&cinfo);
     jpeg_destroy_decompress(&cinfo);
 
+    // TODO: implement getting metadata from GIFs; this is a placeholder
+    *metadata = (char *)malloc(sizeof(char));
+    *metadata[0] = '\0';
+
     return "";
 }

src/decoder/png_decoder.cpp

@@ -1,6 +1,8 @@
 #include "decoder.h"
+#include <iostream>
+
+string decode_png_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg, char ** metadata) {
 
-string decode_png_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg) {
     // check it's a valid png buffer
     if (size < 8 || png_sig_cmp((png_const_bytep) buffer, 0, 8)) {
         return "Invalid PNG buffer";
@@ -43,6 +45,28 @@ string decode_png_buffer(char * buffer, size_t size, CImg<unsigned char> ** cimg
     png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
                  NULL, NULL, NULL);
 
+
+    // get metadata in first text chunk found with keyboard 'lwip_data'
+    png_textp text_ptr;
+    int num_comments = png_get_text(png_ptr, info_ptr, &text_ptr, NULL);
+    bool metadata_found = false;
+
+    for (int i = 0; i < num_comments; i++) {
+        if (strcmp(text_ptr[i].key, "lwip_data") == 0) {
+            int metadata_len = (strlen(text_ptr[i].text) + 1) * sizeof(char);
+            *metadata = (char *)malloc(metadata_len);
+            memcpy(*metadata, text_ptr[i].text, metadata_len);
+            metadata_found = true;
+            break; //TODO: handle multiple lwip_data text chunks?
+        }
+    }
+
+    // if no text chunks with keyword 'lwip_data' are found, set metadata to an empty string
+    if (!metadata_found) {
+        *metadata = (char *)malloc(sizeof(char));
+        *metadata[0] = '\0';
+    }
+
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_set_palette_to_rgb(png_ptr);
         color_type = PNG_COLOR_TYPE_RGB;

src/encoder/encoder.h

@@ -53,6 +53,7 @@ class EncodeToPngBufferWorker : public NanAsyncWorker {
         int compression,
         bool interlaced,
         bool trans,
+        char *metadata,
         NanCallback * callback
     );
     ~EncodeToPngBufferWorker();
@@ -65,6 +66,7 @@ class EncodeToPngBufferWorker : public NanAsyncWorker {
     int _compression;
     bool _interlaced;
     bool _trans;
+    char *_metadata;
     char * _pngbuf;
     size_t _pngbufsize;
 };

src/encoder/init.cpp

@@ -31,7 +31,12 @@ NAN_METHOD(encodeToPngBuffer) {
     int compression = args[3].As<Integer>()->Value();
     bool interlaced = args[4]->BooleanValue();
     bool trans = args[5]->BooleanValue();
-    NanCallback * callback = new NanCallback(args[6].As<Function>());
+
+    int metadata_len = args[6].As<String>()->Utf8Length();
+    char *metadata = (char *)malloc(metadata_len * sizeof(char));
+    args[6].As<String>()->WriteUtf8(metadata);
+
+    NanCallback * callback = new NanCallback(args[7].As<Function>());
 
     NanAsyncQueueWorker(
         new EncodeToPngBufferWorker(
@@ -41,6 +46,7 @@ NAN_METHOD(encodeToPngBuffer) {
             compression,
             interlaced,
             trans,
+            metadata,
             callback
         )
     );

src/encoder/png_worker.cpp

@@ -1,4 +1,5 @@
 #include "encoder.h"
+#include <iostream>
 
 #define RGB_N_CHANNELS 3
 #define RGBA_N_CHANNELS 4
@@ -10,17 +11,23 @@ EncodeToPngBufferWorker::EncodeToPngBufferWorker(
     int compression,
     bool interlaced,
     bool trans,
+    char *metadata,
+    // char *metadata,
     NanCallback * callback
 ): NanAsyncWorker(callback), _width(width), _height(height),
-    _compression(compression), _interlaced(interlaced), _trans(trans),
+    _compression(compression), _interlaced(interlaced), _trans(trans), _metadata(metadata),
     _pngbuf(NULL), _pngbufsize(0) {
     SaveToPersistent("buff", buff); // make sure buff isn't GC'ed
     _pixbuf = (unsigned char *) Buffer::Data(buff);
+
+    // SaveToPersistent("metadata", metadata);
+    // _metadata = (char *)metadata;
 }
 
 EncodeToPngBufferWorker::~EncodeToPngBufferWorker() {}
 
 void EncodeToPngBufferWorker::Execute () {
+
     int n_chan = _trans ? RGBA_N_CHANNELS : RGB_N_CHANNELS;
     unsigned int rowBytes = _width * n_chan;
     int interlaceType;
@@ -97,6 +104,17 @@ void EncodeToPngBufferWorker::Execute () {
         PNG_COMPRESSION_TYPE_DEFAULT,
         PNG_FILTER_TYPE_DEFAULT
     );
+
+    // set metadata in tEXt chunk
+    if (strlen(_metadata) > 0) {
+        png_text metadata;
+        metadata.compression = PNG_TEXT_COMPRESSION_NONE;
+        metadata.key = "lwip_data";
+        metadata.text = _metadata;
+
+        png_set_text(png_ptr, info_ptr, &metadata, 1);
+    }
+
     png_set_compression_level(png_ptr, compLevel);
 
     pngWriteCbData buffinf = {NULL, 0};
@@ -164,4 +182,4 @@ void pngWriteCB(png_structp png_ptr, png_bytep data, png_size_t length) {
 
     memcpy(buffinf->buff + buffinf->buffsize, data, length);
     buffinf->buffsize += length;
-}
+}