@revizly/sharp 0.33.2-revizly13

package/src/pipeline.h

@@ -0,0 +1,385 @@
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef SRC_PIPELINE_H_
+#define SRC_PIPELINE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "./common.h"
+
+Napi::Value pipeline(const Napi::CallbackInfo& info);
+
+struct Composite {
+  sharp::InputDescriptor *input;
+  VipsBlendMode mode;
+  int gravity;
+  int left;
+  int top;
+  bool hasOffset;
+  bool tile;
+  bool premultiplied;
+
+  Composite():
+    input(nullptr),
+    mode(VIPS_BLEND_MODE_OVER),
+    gravity(0),
+    left(0),
+    top(0),
+    hasOffset(false),
+    tile(false),
+    premultiplied(false) {}
+};
+
+struct PipelineBaton {
+  sharp::InputDescriptor *input;
+  std::string formatOut;
+  std::string fileOut;
+  void *bufferOut;
+  size_t bufferOutLength;
+  std::vector<Composite *> composite;
+  std::vector<sharp::InputDescriptor *> joinChannelIn;
+  int topOffsetPre;
+  int leftOffsetPre;
+  int widthPre;
+  int heightPre;
+  int topOffsetPost;
+  int leftOffsetPost;
+  int widthPost;
+  int heightPost;
+  int width;
+  int height;
+  int channels;
+  VipsKernel kernel;
+  sharp::Canvas canvas;
+  int position;
+  std::vector<double> resizeBackground;
+  bool hasCropOffset;
+  int cropOffsetLeft;
+  int cropOffsetTop;
+  bool hasAttentionCenter;
+  int attentionX;
+  int attentionY;
+  bool premultiplied;
+  bool tileCentre;
+  bool fastShrinkOnLoad;
+  std::vector<double> tint;
+  bool flatten;
+  std::vector<double> flattenBackground;
+  bool unflatten;
+  bool negate;
+  bool negateAlpha;
+  double blurSigma;
+  double brightness;
+  double saturation;
+  int hue;
+  double lightness;
+  int medianSize;
+  double sharpenSigma;
+  double sharpenM1;
+  double sharpenM2;
+  double sharpenX1;
+  double sharpenY2;
+  double sharpenY3;
+  int threshold;
+  bool thresholdGrayscale;
+  std::vector<double> trimBackground;
+  double trimThreshold;
+  bool trimLineArt;
+  int trimOffsetLeft;
+  int trimOffsetTop;
+  std::vector<double> linearA;
+  std::vector<double> linearB;
+  double gamma;
+  double gammaOut;
+  bool greyscale;
+  bool normalise;
+  int normaliseLower;
+  int normaliseUpper;
+  int claheWidth;
+  int claheHeight;
+  int claheMaxSlope;
+  bool useExifOrientation;
+  int angle;
+  double rotationAngle;
+  std::vector<double> rotationBackground;
+  bool rotateBeforePreExtract;
+  bool flip;
+  bool flop;
+  int extendTop;
+  int extendBottom;
+  int extendLeft;
+  int extendRight;
+  std::vector<double> extendBackground;
+  VipsExtend extendWith;
+  bool withoutEnlargement;
+  bool withoutReduction;
+  std::vector<double> affineMatrix;
+  std::vector<double> affineBackground;
+  double affineIdx;
+  double affineIdy;
+  double affineOdx;
+  double affineOdy;
+  std::string affineInterpolator;
+  int jpegQuality;
+  bool jpegProgressive;
+  std::string jpegChromaSubsampling;
+  bool jpegTrellisQuantisation;
+  int jpegQuantisationTable;
+  bool jpegOvershootDeringing;
+  bool jpegOptimiseScans;
+  bool jpegOptimiseCoding;
+  bool pngProgressive;
+  int pngCompressionLevel;
+  bool pngAdaptiveFiltering;
+  bool pngPalette;
+  int pngQuality;
+  int pngEffort;
+  int pngBitdepth;
+  double pngDither;
+  int jp2Quality;
+  bool jp2Lossless;
+  int jp2TileHeight;
+  int jp2TileWidth;
+  std::string jp2ChromaSubsampling;
+  int webpQuality;
+  int webpAlphaQuality;
+  bool webpNearLossless;
+  bool webpLossless;
+  bool webpSmartSubsample;
+  VipsForeignWebpPreset webpPreset;
+  int webpEffort;
+  bool webpMinSize;
+  bool webpMixed;
+  int gifBitdepth;
+  int gifEffort;
+  double gifDither;
+  double gifInterFrameMaxError;
+  double gifInterPaletteMaxError;
+  bool gifReuse;
+  bool gifProgressive;
+  int tiffQuality;
+  VipsForeignTiffCompression tiffCompression;
+  VipsForeignTiffPredictor tiffPredictor;
+  bool tiffPyramid;
+  int tiffBitdepth;
+  bool tiffMiniswhite;
+  bool tiffTile;
+  int tiffTileHeight;
+  int tiffTileWidth;
+  double tiffXres;
+  double tiffYres;
+  VipsForeignTiffResunit tiffResolutionUnit;
+  int heifQuality;
+  VipsForeignHeifCompression heifCompression;
+  int heifEffort;
+  std::string heifChromaSubsampling;
+  bool heifLossless;
+  double jxlDistance;
+  int jxlDecodingTier;
+  int jxlEffort;
+  bool jxlLossless;
+  VipsBandFormat rawDepth;
+  std::string err;
+  int keepMetadata;
+  int withMetadataOrientation;
+  double withMetadataDensity;
+  std::string withIccProfile;
+  std::unordered_map<std::string, std::string> withExif;
+  bool withExifMerge;
+  int timeoutSeconds;
+  std::unique_ptr<double[]> convKernel;
+  int convKernelWidth;
+  int convKernelHeight;
+  double convKernelScale;
+  double convKernelOffset;
+  sharp::InputDescriptor *boolean;
+  VipsOperationBoolean booleanOp;
+  VipsOperationBoolean bandBoolOp;
+  int extractChannel;
+  bool removeAlpha;
+  double ensureAlpha;
+  VipsInterpretation colourspacePipeline;
+  VipsInterpretation colourspace;
+  std::vector<int> delay;
+  int loop;
+  int tileSize;
+  int tileOverlap;
+  VipsForeignDzContainer tileContainer;
+  VipsForeignDzLayout tileLayout;
+  std::string tileFormat;
+  int tileAngle;
+  std::vector<double> tileBackground;
+  int tileSkipBlanks;
+  VipsForeignDzDepth tileDepth;
+  std::string tileId;
+  std::string tileBasename;
+  std::unique_ptr<double[]> recombMatrix;
+
+  PipelineBaton():
+    input(nullptr),
+    bufferOutLength(0),
+    topOffsetPre(-1),
+    topOffsetPost(-1),
+    channels(0),
+    kernel(VIPS_KERNEL_LANCZOS3),
+    canvas(sharp::Canvas::CROP),
+    position(0),
+    resizeBackground{ 0.0, 0.0, 0.0, 255.0 },
+    hasCropOffset(false),
+    cropOffsetLeft(0),
+    cropOffsetTop(0),
+    hasAttentionCenter(false),
+    attentionX(0),
+    attentionY(0),
+    premultiplied(false),
+    tint{ -1.0, 0.0, 0.0, 0.0 },
+    flatten(false),
+    flattenBackground{ 0.0, 0.0, 0.0 },
+    unflatten(false),
+    negate(false),
+    negateAlpha(true),
+    blurSigma(0.0),
+    brightness(1.0),
+    saturation(1.0),
+    hue(0),
+    lightness(0),
+    medianSize(0),
+    sharpenSigma(0.0),
+    sharpenM1(1.0),
+    sharpenM2(2.0),
+    sharpenX1(2.0),
+    sharpenY2(10.0),
+    sharpenY3(20.0),
+    threshold(0),
+    thresholdGrayscale(true),
+    trimBackground{},
+    trimThreshold(-1.0),
+    trimLineArt(false),
+    trimOffsetLeft(0),
+    trimOffsetTop(0),
+    linearA{},
+    linearB{},
+    gamma(0.0),
+    greyscale(false),
+    normalise(false),
+    normaliseLower(1),
+    normaliseUpper(99),
+    claheWidth(0),
+    claheHeight(0),
+    claheMaxSlope(3),
+    useExifOrientation(false),
+    angle(0),
+    rotationAngle(0.0),
+    rotationBackground{ 0.0, 0.0, 0.0, 255.0 },
+    flip(false),
+    flop(false),
+    extendTop(0),
+    extendBottom(0),
+    extendLeft(0),
+    extendRight(0),
+    extendBackground{ 0.0, 0.0, 0.0, 255.0 },
+    extendWith(VIPS_EXTEND_BACKGROUND),
+    withoutEnlargement(false),
+    withoutReduction(false),
+    affineMatrix{ 1.0, 0.0, 0.0, 1.0 },
+    affineBackground{ 0.0, 0.0, 0.0, 255.0 },
+    affineIdx(0),
+    affineIdy(0),
+    affineOdx(0),
+    affineOdy(0),
+    affineInterpolator("bicubic"),
+    jpegQuality(80),
+    jpegProgressive(false),
+    jpegChromaSubsampling("4:2:0"),
+    jpegTrellisQuantisation(false),
+    jpegQuantisationTable(0),
+    jpegOvershootDeringing(false),
+    jpegOptimiseScans(false),
+    jpegOptimiseCoding(true),
+    pngProgressive(false),
+    pngCompressionLevel(6),
+    pngAdaptiveFiltering(false),
+    pngPalette(false),
+    pngQuality(100),
+    pngEffort(7),
+    pngBitdepth(8),
+    pngDither(1.0),
+    jp2Quality(80),
+    jp2Lossless(false),
+    jp2TileHeight(512),
+    jp2TileWidth(512),
+    jp2ChromaSubsampling("4:4:4"),
+    webpQuality(80),
+    webpAlphaQuality(100),
+    webpNearLossless(false),
+    webpLossless(false),
+    webpSmartSubsample(false),
+    webpPreset(VIPS_FOREIGN_WEBP_PRESET_DEFAULT),
+    webpEffort(4),
+    webpMinSize(false),
+    webpMixed(false),
+    gifBitdepth(8),
+    gifEffort(7),
+    gifDither(1.0),
+    gifInterFrameMaxError(0.0),
+    gifInterPaletteMaxError(3.0),
+    gifReuse(true),
+    gifProgressive(false),
+    tiffQuality(80),
+    tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
+    tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
+    tiffPyramid(false),
+    tiffBitdepth(8),
+    tiffMiniswhite(false),
+    tiffTile(false),
+    tiffTileHeight(256),
+    tiffTileWidth(256),
+    tiffXres(1.0),
+    tiffYres(1.0),
+    tiffResolutionUnit(VIPS_FOREIGN_TIFF_RESUNIT_INCH),
+    heifQuality(50),
+    heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_AV1),
+    heifEffort(4),
+    heifChromaSubsampling("4:4:4"),
+    heifLossless(false),
+    jxlDistance(1.0),
+    jxlDecodingTier(0),
+    jxlEffort(7),
+    jxlLossless(false),
+    rawDepth(VIPS_FORMAT_UCHAR),
+    keepMetadata(0),
+    withMetadataOrientation(-1),
+    withMetadataDensity(0.0),
+    withExifMerge(true),
+    timeoutSeconds(0),
+    convKernelWidth(0),
+    convKernelHeight(0),
+    convKernelScale(0.0),
+    convKernelOffset(0.0),
+    boolean(nullptr),
+    booleanOp(VIPS_OPERATION_BOOLEAN_LAST),
+    bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
+    extractChannel(-1),
+    removeAlpha(false),
+    ensureAlpha(-1.0),
+    colourspacePipeline(VIPS_INTERPRETATION_LAST),
+    colourspace(VIPS_INTERPRETATION_LAST),
+    loop(-1),
+    tileSize(256),
+    tileOverlap(0),
+    tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),
+    tileLayout(VIPS_FOREIGN_DZ_LAYOUT_DZ),
+    tileAngle(0),
+    tileBackground{ 255.0, 255.0, 255.0, 255.0 },
+    tileSkipBlanks(-1),
+    tileDepth(VIPS_FOREIGN_DZ_DEPTH_LAST) {}
+};
+
+#endif  // SRC_PIPELINE_H_

package/src/sharp.cc

@@ -0,0 +1,40 @@
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+#include <mutex>  // NOLINT(build/c++11)
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "common.h"
+#include "metadata.h"
+#include "pipeline.h"
+#include "utilities.h"
+#include "stats.h"
+
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  static std::once_flag sharp_vips_init_once;
+  std::call_once(sharp_vips_init_once, []() {
+    vips_init("sharp");
+  });
+
+  g_log_set_handler("VIPS", static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING),
+    static_cast<GLogFunc>(sharp::VipsWarningCallback), nullptr);
+
+  // Methods available to JavaScript
+  exports.Set("metadata", Napi::Function::New(env, metadata));
+  exports.Set("pipeline", Napi::Function::New(env, pipeline));
+  exports.Set("cache", Napi::Function::New(env, cache));
+  exports.Set("concurrency", Napi::Function::New(env, concurrency));
+  exports.Set("counters", Napi::Function::New(env, counters));
+  exports.Set("simd", Napi::Function::New(env, simd));
+  exports.Set("libvipsVersion", Napi::Function::New(env, libvipsVersion));
+  exports.Set("format", Napi::Function::New(env, format));
+  exports.Set("block", Napi::Function::New(env, block));
+  exports.Set("_maxColourDistance", Napi::Function::New(env, _maxColourDistance));
+  exports.Set("_isUsingJemalloc", Napi::Function::New(env, _isUsingJemalloc));
+  exports.Set("stats", Napi::Function::New(env, stats));
+  return exports;
+}
+
+NODE_API_MODULE(sharp, init)

package/src/stats.cc

@@ -0,0 +1,183 @@
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+#include <numeric>
+#include <vector>
+#include <iostream>
+
+#include <napi.h>
+#include <vips/vips8>
+
+#include "common.h"
+#include "stats.h"
+
+class StatsWorker : public Napi::AsyncWorker {
+ public:
+  StatsWorker(Napi::Function callback, StatsBaton *baton, Napi::Function debuglog) :
+    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
+  ~StatsWorker() {}
+
+  const int STAT_MIN_INDEX = 0;
+  const int STAT_MAX_INDEX = 1;
+  const int STAT_SUM_INDEX = 2;
+  const int STAT_SQ_SUM_INDEX = 3;
+  const int STAT_MEAN_INDEX = 4;
+  const int STAT_STDEV_INDEX = 5;
+  const int STAT_MINX_INDEX = 6;
+  const int STAT_MINY_INDEX = 7;
+  const int STAT_MAXX_INDEX = 8;
+  const int STAT_MAXY_INDEX = 9;
+
+  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) {
+      try {
+        vips::VImage stats = image.stats();
+        int const bands = image.bands();
+        for (int b = 1; b <= bands; b++) {
+          ChannelStats cStats(
+            static_cast<int>(stats.getpoint(STAT_MIN_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAX_INDEX, b).front()),
+            stats.getpoint(STAT_SUM_INDEX, b).front(),
+            stats.getpoint(STAT_SQ_SUM_INDEX, b).front(),
+            stats.getpoint(STAT_MEAN_INDEX, b).front(),
+            stats.getpoint(STAT_STDEV_INDEX, b).front(),
+            static_cast<int>(stats.getpoint(STAT_MINX_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MINY_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAXX_INDEX, b).front()),
+            static_cast<int>(stats.getpoint(STAT_MAXY_INDEX, b).front()));
+          baton->channelStats.push_back(cStats);
+        }
+        // Image is not opaque when alpha layer is present and contains a non-mamixa value
+        if (sharp::HasAlpha(image)) {
+          double const minAlpha = static_cast<double>(stats.getpoint(STAT_MIN_INDEX, bands).front());
+          if (minAlpha != sharp::MaximumImageAlpha(image.interpretation())) {
+            baton->isOpaque = false;
+          }
+        }
+        // Convert to greyscale
+        vips::VImage greyscale = image.colourspace(VIPS_INTERPRETATION_B_W)[0];
+        // Estimate entropy via histogram of greyscale value frequency
+        baton->entropy = std::abs(greyscale.hist_find().hist_entropy());
+        // Estimate sharpness via standard deviation of greyscale laplacian
+        if (image.width() > 1 || image.height() > 1) {
+          VImage laplacian = VImage::new_matrixv(3, 3,
+            0.0,  1.0, 0.0,
+            1.0, -4.0, 1.0,
+            0.0,  1.0, 0.0);
+          laplacian.set("scale", 9.0);
+          baton->sharpness = greyscale.conv(laplacian).deviate();
+        }
+        // Most dominant sRGB colour via 4096-bin 3D histogram
+        vips::VImage hist = sharp::RemoveAlpha(image)
+          .colourspace(VIPS_INTERPRETATION_sRGB)
+          .hist_find_ndim(VImage::option()->set("bins", 16));
+        std::complex<double> maxpos = hist.maxpos();
+        int const dx = static_cast<int>(std::real(maxpos));
+        int const dy = static_cast<int>(std::imag(maxpos));
+        std::vector<double> pel = hist(dx, dy);
+        int const dz = std::distance(pel.begin(), std::find(pel.begin(), pel.end(), hist.max()));
+        baton->dominantRed = dx * 16 + 8;
+        baton->dominantGreen = dy * 16 + 8;
+        baton->dominantBlue = dz * 16 + 8;
+      } catch (vips::VError const &err) {
+        (baton->err).append(err.what());
+      }
+    }
+
+    // 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()) {
+      // Stats Object
+      Napi::Object info = Napi::Object::New(env);
+      Napi::Array channels = Napi::Array::New(env);
+
+      std::vector<ChannelStats>::iterator it;
+      int i = 0;
+      for (it = baton->channelStats.begin(); it < baton->channelStats.end(); it++, i++) {
+        Napi::Object channelStat = Napi::Object::New(env);
+        channelStat.Set("min", it->min);
+        channelStat.Set("max", it->max);
+        channelStat.Set("sum", it->sum);
+        channelStat.Set("squaresSum", it->squaresSum);
+        channelStat.Set("mean", it->mean);
+        channelStat.Set("stdev", it->stdev);
+        channelStat.Set("minX", it->minX);
+        channelStat.Set("minY", it->minY);
+        channelStat.Set("maxX", it->maxX);
+        channelStat.Set("maxY", it->maxY);
+        channels.Set(i, channelStat);
+      }
+
+      info.Set("channels", channels);
+      info.Set("isOpaque", baton->isOpaque);
+      info.Set("entropy", baton->entropy);
+      info.Set("sharpness", baton->sharpness);
+      Napi::Object dominant = Napi::Object::New(env);
+      dominant.Set("r", baton->dominantRed);
+      dominant.Set("g", baton->dominantGreen);
+      dominant.Set("b", baton->dominantBlue);
+      info.Set("dominant", dominant);
+      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:
+  StatsBaton* baton;
+  Napi::FunctionReference debuglog;
+};
+
+/*
+  stats(options, callback)
+*/
+Napi::Value stats(const Napi::CallbackInfo& info) {
+  // V8 objects are converted to non-V8 types held in the baton struct
+  StatsBaton *baton = new StatsBaton;
+  Napi::Object options = info[size_t(0)].As<Napi::Object>();
+
+  // Input
+  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
+  baton->input->access = VIPS_ACCESS_RANDOM;
+
+  // 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>();
+  StatsWorker *worker = new StatsWorker(callback, baton, debuglog);
+  worker->Receiver().Set("options", options);
+  worker->Queue();
+
+  // Increment queued task counter
+  sharp::counterQueue++;
+
+  return info.Env().Undefined();
+}

package/src/stats.h

@@ -0,0 +1,59 @@
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef SRC_STATS_H_
+#define SRC_STATS_H_
+
+#include <string>
+#include <napi.h>
+
+#include "./common.h"
+
+struct ChannelStats {
+  // stats per channel
+  int min;
+  int max;
+  double sum;
+  double squaresSum;
+  double mean;
+  double stdev;
+  int minX;
+  int minY;
+  int maxX;
+  int maxY;
+
+  ChannelStats(int minVal, int maxVal, double sumVal, double squaresSumVal,
+    double meanVal, double stdevVal, int minXVal, int minYVal, int maxXVal, int maxYVal):
+    min(minVal), max(maxVal), sum(sumVal), squaresSum(squaresSumVal),
+    mean(meanVal), stdev(stdevVal), minX(minXVal), minY(minYVal), maxX(maxXVal), maxY(maxYVal) {}
+};
+
+struct StatsBaton {
+  // Input
+  sharp::InputDescriptor *input;
+
+  // Output
+  std::vector<ChannelStats> channelStats;
+  bool isOpaque;
+  double entropy;
+  double sharpness;
+  int dominantRed;
+  int dominantGreen;
+  int dominantBlue;
+
+  std::string err;
+
+  StatsBaton():
+    input(nullptr),
+    isOpaque(true),
+    entropy(0.0),
+    sharpness(0.0),
+    dominantRed(0),
+    dominantGreen(0),
+    dominantBlue(0)
+    {}
+};
+
+Napi::Value stats(const Napi::CallbackInfo& info);
+
+#endif  // SRC_STATS_H_