@revizly/sharp 0.33.2-revizly3

package/src/common.h

@@ -0,0 +1,393 @@
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef SRC_COMMON_H_
+#define SRC_COMMON_H_
+
+#include <string>
+#include <tuple>
+#include <vector>
+#include <atomic>
+
+#include <napi.h>
+#include <vips/vips8>
+
+// Verify platform and compiler compatibility
+
+#if (VIPS_MAJOR_VERSION < 8) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 15) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 15 && VIPS_MICRO_VERSION < 1)
+#error "libvips version 8.15.1+ is required - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
+#error "GCC version 4.6+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+
+#if (defined(__clang__) && defined(__has_feature))
+#if (!__has_feature(cxx_range_for))
+#error "clang version 3.0+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#endif
+#endif
+
+using vips::VImage;
+
+namespace sharp {
+
+  struct InputDescriptor {  // NOLINT(runtime/indentation_namespace)
+    std::string name;
+    std::string file;
+    char *buffer;
+    VipsFailOn failOn;
+    uint64_t limitInputPixels;
+    bool unlimited;
+    VipsAccess access;
+    size_t bufferLength;
+    bool isBuffer;
+    double density;
+    bool ignoreIcc;
+    VipsBandFormat rawDepth;
+    int rawChannels;
+    int rawWidth;
+    int rawHeight;
+    bool rawPremultiplied;
+    int pages;
+    int page;
+    int level;
+    int subifd;
+    int createChannels;
+    int createWidth;
+    int createHeight;
+    std::vector<double> createBackground;
+    std::string createNoiseType;
+    double createNoiseMean;
+    double createNoiseSigma;
+    std::string textValue;
+    std::string textFont;
+    std::string textFontfile;
+    int textWidth;
+    int textHeight;
+    VipsAlign textAlign;
+    bool textJustify;
+    int textDpi;
+    bool textRgba;
+    int textSpacing;
+    VipsTextWrap textWrap;
+    int textAutofitDpi;
+
+    InputDescriptor():
+      buffer(nullptr),
+      failOn(VIPS_FAIL_ON_WARNING),
+      limitInputPixels(0x3FFF * 0x3FFF),
+      unlimited(FALSE),
+      access(VIPS_ACCESS_RANDOM),
+      bufferLength(0),
+      isBuffer(FALSE),
+      density(72.0),
+      ignoreIcc(FALSE),
+      rawDepth(VIPS_FORMAT_UCHAR),
+      rawChannels(0),
+      rawWidth(0),
+      rawHeight(0),
+      rawPremultiplied(false),
+      pages(1),
+      page(0),
+      level(0),
+      subifd(-1),
+      createChannels(0),
+      createWidth(0),
+      createHeight(0),
+      createBackground{ 0.0, 0.0, 0.0, 255.0 },
+      createNoiseMean(0.0),
+      createNoiseSigma(0.0),
+      textWidth(0),
+      textHeight(0),
+      textAlign(VIPS_ALIGN_LOW),
+      textJustify(FALSE),
+      textDpi(72),
+      textRgba(FALSE),
+      textSpacing(0),
+      textWrap(VIPS_TEXT_WRAP_WORD),
+      textAutofitDpi(0) {}
+  };
+
+  // Convenience methods to access the attributes of a Napi::Object
+  bool HasAttr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, std::string attr);
+  std::string AttrAsStr(Napi::Object obj, unsigned int const attr);
+  uint32_t AttrAsUint32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, std::string attr);
+  int32_t AttrAsInt32(Napi::Object obj, unsigned int const attr);
+  double AttrAsDouble(Napi::Object obj, std::string attr);
+  double AttrAsDouble(Napi::Object obj, unsigned int const attr);
+  bool AttrAsBool(Napi::Object obj, std::string attr);
+  std::vector<double> AttrAsVectorOfDouble(Napi::Object obj, std::string attr);
+  std::vector<int32_t> AttrAsInt32Vector(Napi::Object obj, std::string attr);
+  template <class T> T AttrAsEnum(Napi::Object obj, std::string attr, GType type) {
+    return static_cast<T>(
+      vips_enum_from_nick(nullptr, type, AttrAsStr(obj, attr).data()));
+  }
+
+  // Create an InputDescriptor instance from a Napi::Object describing an input image
+  InputDescriptor* CreateInputDescriptor(Napi::Object input);
+
+  enum class ImageType {
+    JPEG,
+    PNG,
+    WEBP,
+    JP2,
+    TIFF,
+    GIF,
+    SVG,
+    HEIF,
+    PDF,
+    MAGICK,
+    OPENSLIDE,
+    PPM,
+    FITS,
+    EXR,
+    JXL,
+    VIPS,
+    RAW,
+    UNKNOWN,
+    MISSING
+  };
+
+  enum class Canvas {
+      CROP,
+      EMBED,
+      MAX,
+      MIN,
+      IGNORE_ASPECT
+  };
+
+  // How many tasks are in the queue?
+  extern std::atomic<int> counterQueue;
+
+  // How many tasks are being processed?
+  extern std::atomic<int> counterProcess;
+
+  // Filename extension checkers
+  bool IsJpeg(std::string const &str);
+  bool IsPng(std::string const &str);
+  bool IsWebp(std::string const &str);
+  bool IsJp2(std::string const &str);
+  bool IsGif(std::string const &str);
+  bool IsTiff(std::string const &str);
+  bool IsHeic(std::string const &str);
+  bool IsHeif(std::string const &str);
+  bool IsAvif(std::string const &str);
+  bool IsJxl(std::string const &str);
+  bool IsDz(std::string const &str);
+  bool IsDzZip(std::string const &str);
+  bool IsV(std::string const &str);
+
+  /*
+    Trim space from end of string.
+  */
+  std::string TrimEnd(std::string const &str);
+
+  /*
+    Provide a string identifier for the given image type.
+  */
+  std::string ImageTypeId(ImageType const imageType);
+
+  /*
+    Determine image format of a buffer.
+  */
+  ImageType DetermineImageType(void *buffer, size_t const length);
+
+  /*
+    Determine image format of a file.
+  */
+  ImageType DetermineImageType(char const *file);
+
+  /*
+    Does this image type support multiple pages?
+  */
+  bool ImageTypeSupportsPage(ImageType imageType);
+
+  /*
+    Does this image type support removal of safety limits?
+  */
+  bool ImageTypeSupportsUnlimited(ImageType imageType);
+
+  /*
+    Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
+  */
+  std::tuple<VImage, ImageType> OpenInput(InputDescriptor *descriptor);
+
+  /*
+    Does this image have an embedded profile?
+  */
+  bool HasProfile(VImage image);
+
+  /*
+    Get copy of embedded profile.
+  */
+  std::pair<char*, size_t> GetProfile(VImage image);
+
+  /*
+    Set embedded profile.
+  */
+  VImage SetProfile(VImage image, std::pair<char*, size_t> icc);
+
+  /*
+    Does this image have an alpha channel?
+    Uses colour space interpretation with number of channels to guess this.
+  */
+  bool HasAlpha(VImage image);
+
+  /*
+    Remove all EXIF-related image fields.
+  */
+  VImage RemoveExif(VImage image);
+
+  /*
+    Get EXIF Orientation of image, if any.
+  */
+  int ExifOrientation(VImage image);
+
+  /*
+    Set EXIF Orientation of image.
+  */
+  VImage SetExifOrientation(VImage image, int const orientation);
+
+  /*
+    Remove EXIF Orientation from image.
+  */
+  VImage RemoveExifOrientation(VImage image);
+
+  /*
+    Set animation properties if necessary.
+  */
+  VImage SetAnimationProperties(VImage image, int nPages, int pageHeight, std::vector<int> delay, int loop);
+
+  /*
+    Remove animation properties from image.
+  */
+  VImage RemoveAnimationProperties(VImage image);
+
+  /*
+    Remove GIF palette from image.
+  */
+  VImage RemoveGifPalette(VImage image);
+
+  /*
+    Does this image have a non-default density?
+  */
+  bool HasDensity(VImage image);
+
+  /*
+    Get pixels/mm resolution as pixels/inch density.
+  */
+  int GetDensity(VImage image);
+
+  /*
+    Set pixels/mm resolution based on a pixels/inch density.
+  */
+  VImage SetDensity(VImage image, const double density);
+
+  /*
+    Multi-page images can have a page height. Fetch it, and sanity check it.
+    If page-height is not set, it defaults to the image height
+  */
+  int GetPageHeight(VImage image);
+
+  /*
+    Check the proposed format supports the current dimensions.
+  */
+  void AssertImageTypeDimensions(VImage image, ImageType const imageType);
+
+  /*
+    Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
+  */
+  extern std::function<void(void*, char*)> FreeCallback;
+
+  /*
+    Called with warnings from the glib-registered "VIPS" domain
+  */
+  void VipsWarningCallback(char const* log_domain, GLogLevelFlags log_level, char const* message, void* ignore);
+
+  /*
+    Pop the oldest warning message from the queue
+  */
+  std::string VipsWarningPop();
+
+  /*
+    Attach an event listener for progress updates, used to detect timeout
+  */
+  void SetTimeout(VImage image, int const timeoutSeconds);
+
+  /*
+    Event listener for progress updates, used to detect timeout
+  */
+  void VipsProgressCallBack(VipsImage *image, VipsProgress *progress, int *timeoutSeconds);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity during an embed.
+  */
+  std::tuple<int, int> CalculateEmbedPosition(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets of the output image.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y);
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation);
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation);
+
+  /*
+    Convert RGBA value to another colourspace
+  */
+  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba,
+    VipsInterpretation const interpretation, bool premultiply);
+
+  /*
+    Apply the alpha channel to a given colour
+   */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour, bool premultiply);
+
+  /*
+    Removes alpha channel, if any.
+  */
+  VImage RemoveAlpha(VImage image);
+
+  /*
+    Ensures alpha channel, if missing.
+  */
+  VImage EnsureAlpha(VImage image, double const value);
+
+  /*
+    Calculate the horizontal and vertical shrink factors, taking the canvas mode into account.
+  */
+  std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
+    Canvas canvas, bool withoutEnlargement, bool withoutReduction);
+
+  /*
+    Ensure decoding remains sequential.
+  */
+  VImage StaySequential(VImage image, VipsAccess access, bool condition = TRUE);
+
+}  // namespace sharp
+
+#endif  // SRC_COMMON_H_

package/src/metadata.cc

@@ -0,0 +1,287 @@
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+#include <numeric>
+#include <vector>
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "common.h"
+#include "metadata.h"
+
+class MetadataWorker : public Napi::AsyncWorker {
+ public:
+  MetadataWorker(Napi::Function callback, MetadataBaton *baton, Napi::Function debuglog) :
+    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
+  ~MetadataWorker() {}
+
+  void Execute() {
+    // Decrement queued task counter
+    sharp::counterQueue--;
+
+    vips::VImage image;
+    sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
+    try {
+      std::tie(image, imageType) = OpenInput(baton->input);
+    } catch (vips::VError const &err) {
+      (baton->err).append(err.what());
+    }
+    if (imageType != sharp::ImageType::UNKNOWN) {
+      // Image type
+      baton->format = sharp::ImageTypeId(imageType);
+      // VipsImage attributes
+      baton->width = image.width();
+      baton->height = image.height();
+      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image.interpretation());
+      baton->channels = image.bands();
+      baton->depth = vips_enum_nick(VIPS_TYPE_BAND_FORMAT, image.format());
+      if (sharp::HasDensity(image)) {
+        baton->density = sharp::GetDensity(image);
+      }
+      if (image.get_typeof("jpeg-chroma-subsample") == VIPS_TYPE_REF_STRING) {
+        baton->chromaSubsampling = image.get_string("jpeg-chroma-subsample");
+      }
+      if (image.get_typeof("interlaced") == G_TYPE_INT) {
+        baton->isProgressive = image.get_int("interlaced") == 1;
+      }
+      if (image.get_typeof("palette-bit-depth") == G_TYPE_INT) {
+        baton->paletteBitDepth = image.get_int("palette-bit-depth");
+      }
+      if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT) {
+        baton->pages = image.get_int(VIPS_META_N_PAGES);
+      }
+      if (image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
+        baton->pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
+      }
+      if (image.get_typeof("loop") == G_TYPE_INT) {
+        baton->loop = image.get_int("loop");
+      }
+      if (image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
+        baton->delay = image.get_array_int("delay");
+      }
+      if (image.get_typeof("heif-primary") == G_TYPE_INT) {
+        baton->pagePrimary = image.get_int("heif-primary");
+      }
+      if (image.get_typeof("heif-compression") == VIPS_TYPE_REF_STRING) {
+        baton->compression = image.get_string("heif-compression");
+      }
+      if (image.get_typeof(VIPS_META_RESOLUTION_UNIT) == VIPS_TYPE_REF_STRING) {
+        baton->resolutionUnit = image.get_string(VIPS_META_RESOLUTION_UNIT);
+      }
+      if (image.get_typeof("magick-format") == VIPS_TYPE_REF_STRING) {
+        baton->formatMagick = image.get_string("magick-format");
+      }
+      if (image.get_typeof("openslide.level-count") == VIPS_TYPE_REF_STRING) {
+        int const levels = std::stoi(image.get_string("openslide.level-count"));
+        for (int l = 0; l < levels; l++) {
+          std::string prefix = "openslide.level[" + std::to_string(l) + "].";
+          int const width = std::stoi(image.get_string((prefix + "width").data()));
+          int const height = std::stoi(image.get_string((prefix + "height").data()));
+          baton->levels.push_back(std::pair<int, int>(width, height));
+        }
+      }
+      if (image.get_typeof(VIPS_META_N_SUBIFDS) == G_TYPE_INT) {
+        baton->subifds = image.get_int(VIPS_META_N_SUBIFDS);
+      }
+      baton->hasProfile = sharp::HasProfile(image);
+      if (image.get_typeof("background") == VIPS_TYPE_ARRAY_DOUBLE) {
+        baton->background = image.get_array_double("background");
+      }
+      // Derived attributes
+      baton->hasAlpha = sharp::HasAlpha(image);
+      baton->orientation = sharp::ExifOrientation(image);
+      // EXIF
+      if (image.get_typeof(VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
+        size_t exifLength;
+        void const *exif = image.get_blob(VIPS_META_EXIF_NAME, &exifLength);
+        baton->exif = static_cast<char*>(g_malloc(exifLength));
+        memcpy(baton->exif, exif, exifLength);
+        baton->exifLength = exifLength;
+      }
+      // ICC profile
+      if (image.get_typeof(VIPS_META_ICC_NAME) == VIPS_TYPE_BLOB) {
+        size_t iccLength;
+        void const *icc = image.get_blob(VIPS_META_ICC_NAME, &iccLength);
+        baton->icc = static_cast<char*>(g_malloc(iccLength));
+        memcpy(baton->icc, icc, iccLength);
+        baton->iccLength = iccLength;
+      }
+      // IPTC
+      if (image.get_typeof(VIPS_META_IPTC_NAME) == VIPS_TYPE_BLOB) {
+        size_t iptcLength;
+        void const *iptc = image.get_blob(VIPS_META_IPTC_NAME, &iptcLength);
+        baton->iptc = static_cast<char *>(g_malloc(iptcLength));
+        memcpy(baton->iptc, iptc, iptcLength);
+        baton->iptcLength = iptcLength;
+      }
+      // XMP
+      if (image.get_typeof(VIPS_META_XMP_NAME) == VIPS_TYPE_BLOB) {
+        size_t xmpLength;
+        void const *xmp = image.get_blob(VIPS_META_XMP_NAME, &xmpLength);
+        baton->xmp = static_cast<char *>(g_malloc(xmpLength));
+        memcpy(baton->xmp, xmp, xmpLength);
+        baton->xmpLength = xmpLength;
+      }
+      // TIFFTAG_PHOTOSHOP
+      if (image.get_typeof(VIPS_META_PHOTOSHOP_NAME) == VIPS_TYPE_BLOB) {
+        size_t tifftagPhotoshopLength;
+        void const *tifftagPhotoshop = image.get_blob(VIPS_META_PHOTOSHOP_NAME, &tifftagPhotoshopLength);
+        baton->tifftagPhotoshop = static_cast<char *>(g_malloc(tifftagPhotoshopLength));
+        memcpy(baton->tifftagPhotoshop, tifftagPhotoshop, tifftagPhotoshopLength);
+        baton->tifftagPhotoshopLength = tifftagPhotoshopLength;
+      }
+    }
+
+    // Clean up
+    vips_error_clear();
+    vips_thread_shutdown();
+  }
+
+  void OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+
+    // Handle warnings
+    std::string warning = sharp::VipsWarningPop();
+    while (!warning.empty()) {
+      debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
+      warning = sharp::VipsWarningPop();
+    }
+
+    if (baton->err.empty()) {
+      Napi::Object info = Napi::Object::New(env);
+      info.Set("format", baton->format);
+      if (baton->input->bufferLength > 0) {
+        info.Set("size", baton->input->bufferLength);
+      }
+      info.Set("width", baton->width);
+      info.Set("height", baton->height);
+      info.Set("space", baton->space);
+      info.Set("channels", baton->channels);
+      info.Set("depth", baton->depth);
+      if (baton->density > 0) {
+        info.Set("density", baton->density);
+      }
+      if (!baton->chromaSubsampling.empty()) {
+        info.Set("chromaSubsampling", baton->chromaSubsampling);
+      }
+      info.Set("isProgressive", baton->isProgressive);
+      if (baton->paletteBitDepth > 0) {
+        info.Set("paletteBitDepth", baton->paletteBitDepth);
+      }
+      if (baton->pages > 0) {
+        info.Set("pages", baton->pages);
+      }
+      if (baton->pageHeight > 0) {
+        info.Set("pageHeight", baton->pageHeight);
+      }
+      if (baton->loop >= 0) {
+        info.Set("loop", baton->loop);
+      }
+      if (!baton->delay.empty()) {
+        int i = 0;
+        Napi::Array delay = Napi::Array::New(env, static_cast<size_t>(baton->delay.size()));
+        for (int const d : baton->delay) {
+          delay.Set(i++, d);
+        }
+        info.Set("delay", delay);
+      }
+      if (baton->pagePrimary > -1) {
+        info.Set("pagePrimary", baton->pagePrimary);
+      }
+      if (!baton->compression.empty()) {
+        info.Set("compression", baton->compression);
+      }
+      if (!baton->resolutionUnit.empty()) {
+        info.Set("resolutionUnit", baton->resolutionUnit == "in" ? "inch" : baton->resolutionUnit);
+      }
+      if (!baton->formatMagick.empty()) {
+        info.Set("formatMagick", baton->formatMagick);
+      }
+      if (!baton->levels.empty()) {
+        int i = 0;
+        Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));
+        for (std::pair<int, int> const &l : baton->levels) {
+          Napi::Object level = Napi::Object::New(env);
+          level.Set("width", l.first);
+          level.Set("height", l.second);
+          levels.Set(i++, level);
+        }
+        info.Set("levels", levels);
+      }
+      if (baton->subifds > 0) {
+        info.Set("subifds", baton->subifds);
+      }
+      if (!baton->background.empty()) {
+        if (baton->background.size() == 3) {
+          Napi::Object background = Napi::Object::New(env);
+          background.Set("r", baton->background[0]);
+          background.Set("g", baton->background[1]);
+          background.Set("b", baton->background[2]);
+          info.Set("background", background);
+        } else {
+          info.Set("background", baton->background[0]);
+        }
+      }
+      info.Set("hasProfile", baton->hasProfile);
+      info.Set("hasAlpha", baton->hasAlpha);
+      if (baton->orientation > 0) {
+        info.Set("orientation", baton->orientation);
+      }
+      if (baton->exifLength > 0) {
+        info.Set("exif", Napi::Buffer<char>::NewOrCopy(env, baton->exif, baton->exifLength, sharp::FreeCallback));
+      }
+      if (baton->iccLength > 0) {
+        info.Set("icc", Napi::Buffer<char>::NewOrCopy(env, baton->icc, baton->iccLength, sharp::FreeCallback));
+      }
+      if (baton->iptcLength > 0) {
+        info.Set("iptc", Napi::Buffer<char>::NewOrCopy(env, baton->iptc, baton->iptcLength, sharp::FreeCallback));
+      }
+      if (baton->xmpLength > 0) {
+        info.Set("xmp", Napi::Buffer<char>::NewOrCopy(env, baton->xmp, baton->xmpLength, sharp::FreeCallback));
+      }
+      if (baton->tifftagPhotoshopLength > 0) {
+        info.Set("tifftagPhotoshop",
+          Napi::Buffer<char>::NewOrCopy(env, baton->tifftagPhotoshop,
+            baton->tifftagPhotoshopLength, sharp::FreeCallback));
+      }
+      Callback().Call(Receiver().Value(), { env.Null(), info });
+    } else {
+      Callback().Call(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
+    }
+
+    delete baton->input;
+    delete baton;
+  }
+
+ private:
+  MetadataBaton* baton;
+  Napi::FunctionReference debuglog;
+};
+
+/*
+  metadata(options, callback)
+*/
+Napi::Value metadata(const Napi::CallbackInfo& info) {
+  // V8 objects are converted to non-V8 types held in the baton struct
+  MetadataBaton *baton = new MetadataBaton;
+  Napi::Object options = info[size_t(0)].As<Napi::Object>();
+
+  // Input
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
+
+  // Function to notify of libvips warnings
+  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
+
+  // Join queue for worker thread
+  Napi::Function callback = info[size_t(1)].As<Napi::Function>();
+  MetadataWorker *worker = new MetadataWorker(callback, baton, debuglog);
+  worker->Receiver().Set("options", options);
+  worker->Queue();
+
+  // Increment queued task counter
+  sharp::counterQueue++;
+
+  return info.Env().Undefined();
+}