sharp 0.33.5 → 0.35.3

package/src/pipeline.h

@@ -1,13 +1,15 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  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 <vector>
 
 #include <napi.h>
 #include <vips/vips8>
@@ -39,12 +41,15 @@ struct Composite {
 
 struct PipelineBaton {
   sharp::InputDescriptor *input;
+  std::vector<sharp::InputDescriptor *> join;
   std::string formatOut;
   std::string fileOut;
   void *bufferOut;
   size_t bufferOutLength;
   int pageHeightOut;
   int pagesOut;
+  bool typedArrayOut;
+  bool hasAlphaOut;
   std::vector<Composite *> composite;
   std::vector<sharp::InputDescriptor *> joinChannelIn;
   int topOffsetPre;
@@ -98,8 +103,11 @@ struct PipelineBaton {
   bool trimLineArt;
   int trimOffsetLeft;
   int trimOffsetTop;
+  int trimMargin;
   std::vector<double> linearA;
   std::vector<double> linearB;
+  int dilateWidth;
+  int erodeWidth;
   double gamma;
   double gammaOut;
   bool greyscale;
@@ -109,11 +117,11 @@ struct PipelineBaton {
   int claheWidth;
   int claheHeight;
   int claheMaxSlope;
-  bool useExifOrientation;
   int angle;
   double rotationAngle;
   std::vector<double> rotationBackground;
-  bool rotateBeforePreExtract;
+  bool rotateBefore;
+  bool orientBefore;
   bool flip;
   bool flop;
   int extendTop;
@@ -157,19 +165,23 @@ struct PipelineBaton {
   bool webpNearLossless;
   bool webpLossless;
   bool webpSmartSubsample;
+  bool webpSmartDeblock;
   VipsForeignWebpPreset webpPreset;
   int webpEffort;
   bool webpMinSize;
   bool webpMixed;
+  bool webpExact;
   int gifBitdepth;
   int gifEffort;
   double gifDither;
   double gifInterFrameMaxError;
   double gifInterPaletteMaxError;
+  bool gifKeepDuplicateFrames;
   bool gifReuse;
   bool gifProgressive;
   int tiffQuality;
   VipsForeignTiffCompression tiffCompression;
+  bool tiffBigtiff;
   VipsForeignTiffPredictor tiffPredictor;
   bool tiffPyramid;
   int tiffBitdepth;
@@ -186,18 +198,23 @@ struct PipelineBaton {
   std::string heifChromaSubsampling;
   bool heifLossless;
   int heifBitdepth;
+  std::string heifTune;
   double jxlDistance;
   int jxlDecodingTier;
   int jxlEffort;
   bool jxlLossless;
   VipsBandFormat rawDepth;
   std::string err;
+  bool errUseWarning;
   int keepMetadata;
   int withMetadataOrientation;
   double withMetadataDensity;
   std::string withIccProfile;
   std::unordered_map<std::string, std::string> withExif;
   bool withExifMerge;
+  std::string withXmp;
+  bool withGainMap;
+  bool keepGainMap;
   int timeoutSeconds;
   std::vector<double> convKernel;
   int convKernelWidth;
@@ -232,6 +249,8 @@ struct PipelineBaton {
     bufferOutLength(0),
     pageHeightOut(0),
     pagesOut(0),
+    typedArrayOut(false),
+    hasAlphaOut(false),
     topOffsetPre(-1),
     topOffsetPost(-1),
     channels(0),
@@ -271,8 +290,11 @@ struct PipelineBaton {
     trimLineArt(false),
     trimOffsetLeft(0),
     trimOffsetTop(0),
+    trimMargin(0),
     linearA{},
     linearB{},
+    dilateWidth(0),
+    erodeWidth(0),
     gamma(0.0),
     greyscale(false),
     normalise(false),
@@ -281,7 +303,6 @@ struct PipelineBaton {
     claheWidth(0),
     claheHeight(0),
     claheMaxSlope(3),
-    useExifOrientation(false),
     angle(0),
     rotationAngle(0.0),
     rotationBackground{ 0.0, 0.0, 0.0, 255.0 },
@@ -328,22 +349,26 @@ struct PipelineBaton {
     webpNearLossless(false),
     webpLossless(false),
     webpSmartSubsample(false),
+    webpSmartDeblock(false),
     webpPreset(VIPS_FOREIGN_WEBP_PRESET_DEFAULT),
     webpEffort(4),
     webpMinSize(false),
     webpMixed(false),
+    webpExact(false),
     gifBitdepth(8),
     gifEffort(7),
     gifDither(1.0),
     gifInterFrameMaxError(0.0),
     gifInterPaletteMaxError(3.0),
+    gifKeepDuplicateFrames(false),
     gifReuse(true),
     gifProgressive(false),
     tiffQuality(80),
     tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
+    tiffBigtiff(false),
     tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
     tiffPyramid(false),
-    tiffBitdepth(8),
+    tiffBitdepth(0),
     tiffMiniswhite(false),
     tiffTile(false),
     tiffTileHeight(256),
@@ -357,15 +382,19 @@ struct PipelineBaton {
     heifChromaSubsampling("4:4:4"),
     heifLossless(false),
     heifBitdepth(8),
+    heifTune("auto"),
     jxlDistance(1.0),
     jxlDecodingTier(0),
     jxlEffort(7),
     jxlLossless(false),
     rawDepth(VIPS_FORMAT_UCHAR),
+    errUseWarning(false),
     keepMetadata(0),
     withMetadataOrientation(-1),
     withMetadataDensity(0.0),
     withExifMerge(true),
+    withGainMap(false),
+    keepGainMap(false),
     timeoutSeconds(0),
     convKernelWidth(0),
     convKernelHeight(0),

package/src/sharp.cc

@@ -1,16 +1,18 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
-#include <mutex>  // NOLINT(build/c++11)
+#include <mutex>
 
 #include <napi.h>
 #include <vips/vips8>
 
-#include "common.h"
-#include "metadata.h"
-#include "pipeline.h"
-#include "utilities.h"
-#include "stats.h"
+#include "./common.h"
+#include "./metadata.h"
+#include "./pipeline.h"
+#include "./stats.h"
+#include "./utilities.h"
 
 Napi::Object init(Napi::Env env, Napi::Object exports) {
   static std::once_flag sharp_vips_init_once;
@@ -33,6 +35,7 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   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("_isUsingX64V2", Napi::Function::New(env, _isUsingX64V2));
   exports.Set("stats", Napi::Function::New(env, stats));
   return exports;
 }

package/src/stats.cc

@@ -1,15 +1,18 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
+#include <iostream>
 #include <numeric>
+#include <string>
 #include <vector>
-#include <iostream>
 
 #include <napi.h>
 #include <vips/vips8>
 
-#include "common.h"
-#include "stats.h"
+#include "./common.h"
+#include "./stats.h"
 
 class StatsWorker : public Napi::AsyncWorker {
  public:
@@ -36,7 +39,7 @@ class StatsWorker : public Napi::AsyncWorker {
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       (baton->err).append(err.what());
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
@@ -58,9 +61,9 @@ class StatsWorker : public Napi::AsyncWorker {
           baton->channelStats.push_back(cStats);
         }
         // Image is not opaque when alpha layer is present and contains a non-mamixa value
-        if (sharp::HasAlpha(image)) {
+        if (image.has_alpha()) {
           double const minAlpha = static_cast<double>(stats.getpoint(STAT_MIN_INDEX, bands).front());
-          if (minAlpha != sharp::MaximumImageAlpha(image.interpretation())) {
+          if (minAlpha != vips_interpretation_max_alpha(image.interpretation())) {
             baton->isOpaque = false;
           }
         }
@@ -89,7 +92,7 @@ class StatsWorker : public Napi::AsyncWorker {
         baton->dominantRed = dx * 16 + 8;
         baton->dominantGreen = dy * 16 + 8;
         baton->dominantBlue = dz * 16 + 8;
-      } catch (vips::VError const &err) {
+      } catch (std::runtime_error const &err) {
         (baton->err).append(err.what());
       }
     }
@@ -106,10 +109,9 @@ class StatsWorker : public Napi::AsyncWorker {
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
+      debuglog.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
-
     if (baton->err.empty()) {
       // Stats Object
       Napi::Object info = Napi::Object::New(env);
@@ -141,9 +143,10 @@ class StatsWorker : public Napi::AsyncWorker {
       dominant.Set("g", baton->dominantGreen);
       dominant.Set("b", baton->dominantBlue);
       info.Set("dominant", dominant);
-      Callback().Call(Receiver().Value(), { env.Null(), info });
+      Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), info });
     } else {
-      Callback().Call(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
+      Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(),
+        { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
     }
 
     delete baton->input;

package/src/stats.h

@@ -1,10 +1,13 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
 #ifndef SRC_STATS_H_
 #define SRC_STATS_H_
 
 #include <string>
+#include <vector>
 #include <napi.h>
 
 #include "./common.h"
@@ -24,7 +27,7 @@ struct ChannelStats {
 
   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),
+    min(minVal), max(maxVal), sum(sumVal), squaresSum(squaresSumVal),  // NOLINT(build/include_what_you_use)
     mean(meanVal), stdev(stdevVal), minX(minXVal), minY(minYVal), maxX(maxXVal), maxY(maxYVal) {}
 };
 

package/src/utilities.cc

@@ -1,17 +1,19 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
 #include <cmath>
-#include <string>
 #include <cstdio>
+#include <string>
 
 #include <napi.h>
 #include <vips/vips8>
 #include <vips/vector.h>
 
-#include "common.h"
-#include "operations.h"
-#include "utilities.h"
+#include "./common.h"
+#include "./operations.h"
+#include "./utilities.h"
 
 /*
   Get and set cache limits
@@ -21,15 +23,15 @@ Napi::Value cache(const Napi::CallbackInfo& info) {
 
   // Set memory limit
   if (info[size_t(0)].IsNumber()) {
-    vips_cache_set_max_mem(info[size_t(0)].As<Napi::Number>().Int32Value() * 1048576);
+    vips_cache_set_max_mem(static_cast<size_t>(info[size_t(0)].As<Napi::Number>().Uint32Value()) * 1048576);
   }
   // Set file limit
   if (info[size_t(1)].IsNumber()) {
-    vips_cache_set_max_files(info[size_t(1)].As<Napi::Number>().Int32Value());
+    vips_cache_set_max_files(info[size_t(1)].As<Napi::Number>().Uint32Value());
   }
   // Set items limit
   if (info[size_t(2)].IsNumber()) {
-    vips_cache_set_max(info[size_t(2)].As<Napi::Number>().Int32Value());
+    vips_cache_set_max(info[size_t(2)].As<Napi::Number>().Uint32Value());
   }
 
   // Get memory stats
@@ -119,8 +121,9 @@ Napi::Value format(const Napi::CallbackInfo& info) {
   Napi::Object format = Napi::Object::New(env);
   for (std::string const f : {
     "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz",
-    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl"
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl", "rad", "dcraw"
   }) {
+    std::string id = f == "jp2k" ? "jp2" : f;
     // Input
     const VipsObjectClass *oc = vips_class_find("VipsOperation", (f + "load").c_str());
     Napi::Boolean hasInputFile = Napi::Boolean::New(env, oc);
@@ -152,11 +155,11 @@ Napi::Value format(const Napi::CallbackInfo& info) {
     output.Set("stream", hasOutputBuffer);
     // Other attributes
     Napi::Object container = Napi::Object::New(env);
-    container.Set("id", f);
+    container.Set("id", id);
     container.Set("input", input);
     container.Set("output", output);
     // Add to set of formats
-    format.Set(f, container);
+    format.Set(id, container);
   }
 
   // Raw, uncompressed data
@@ -233,15 +236,15 @@ Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
   double maxColourDistance;
   try {
     // Premultiply and remove alpha
-    if (sharp::HasAlpha(image1)) {
+    if (image1.has_alpha()) {
       image1 = image1.premultiply().extract_band(1, VImage::option()->set("n", image1.bands() - 1));
     }
-    if (sharp::HasAlpha(image2)) {
+    if (image2.has_alpha()) {
       image2 = image2.premultiply().extract_band(1, VImage::option()->set("n", image2.bands() - 1));
     }
     // Calculate colour distance
     maxColourDistance = image1.dE00(image2).max();
-  } catch (vips::VError const &err) {
+  } catch (std::runtime_error const &err) {
     throw Napi::Error::New(env, err.what());
   }
 
@@ -267,3 +270,20 @@ Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, false);
 }
 #endif
+
+#if defined(__GNUC__) && defined(__x86_64__)
+// Are SSE 4.2 intrinsics available at runtime?
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  unsigned int eax, ebx, ecx, edx;
+  __asm__ __volatile__("cpuid"
+    : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
+    : "a"(1));
+  return Napi::Boolean::New(env, (ecx & 1U << 20) != 0);
+}
+#else
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, false);
+}
+#endif

package/src/utilities.h

@@ -1,5 +1,7 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
 #ifndef SRC_UTILITIES_H_
 #define SRC_UTILITIES_H_
@@ -15,5 +17,6 @@ Napi::Value format(const Napi::CallbackInfo& info);
 void block(const Napi::CallbackInfo& info);
 Napi::Value _maxColourDistance(const Napi::CallbackInfo& info);
 Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info);
+Napi::Value _isUsingX64V2(const Napi::CallbackInfo& info);
 
 #endif  // SRC_UTILITIES_H_

package/install/check.js

@@ -1,41 +0,0 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
-
-'use strict';
-
-try {
-  const { useGlobalLibvips, globalLibvipsVersion, log, spawnRebuild } = require('../lib/libvips');
-
-  const buildFromSource = (msg) => {
-    log(msg);
-    log('Attempting to build from source via node-gyp');
-    try {
-      const addonApi = require('node-addon-api');
-      log(`Found node-addon-api ${addonApi.version || ''}`);
-    } catch (err) {
-      log('Please add node-addon-api to your dependencies');
-      return;
-    }
-    try {
-      const gyp = require('node-gyp');
-      log(`Found node-gyp ${gyp().version}`);
-    } catch (err) {
-      log('Please add node-gyp to your dependencies');
-      return;
-    }
-    log('See https://sharp.pixelplumbing.com/install#building-from-source');
-    const status = spawnRebuild();
-    if (status !== 0) {
-      process.exit(status);
-    }
-  };
-
-  if (useGlobalLibvips(log)) {
-    buildFromSource(`Detected globally-installed libvips v${globalLibvipsVersion()}`);
-  } else if (process.env.npm_config_build_from_source) {
-    buildFromSource('Detected --build-from-source flag');
-  }
-} catch (err) {
-  const summary = err.message.split(/\n/).slice(0, 1);
-  console.log(`sharp: skipping install check: ${summary}`);
-}

package/lib/index.js

@@ -1,16 +0,0 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
-
-'use strict';
-
-const Sharp = require('./constructor');
-require('./input')(Sharp);
-require('./resize')(Sharp);
-require('./composite')(Sharp);
-require('./operation')(Sharp);
-require('./colour')(Sharp);
-require('./channel')(Sharp);
-require('./output')(Sharp);
-require('./utility')(Sharp);
-
-module.exports = Sharp;

package/lib/sharp.js

@@ -1,114 +0,0 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
-
-'use strict';
-
-// Inspects the runtime environment and exports the relevant sharp.node binary
-
-const { familySync, versionSync } = require('detect-libc');
-
-const { runtimePlatformArch, isUnsupportedNodeRuntime, prebuiltPlatforms, minimumLibvipsVersion } = require('./libvips');
-const runtimePlatform = runtimePlatformArch();
-
-const paths = [
-  `../src/build/Release/sharp-${runtimePlatform}.node`,
-  '../src/build/Release/sharp-wasm32.node',
-  `@img/sharp-${runtimePlatform}/sharp.node`,
-  '@img/sharp-wasm32/sharp.node'
-];
-
-let sharp;
-const errors = [];
-for (const path of paths) {
-  try {
-    sharp = require(path);
-    break;
-  } catch (err) {
-    /* istanbul ignore next */
-    errors.push(err);
-  }
-}
-
-/* istanbul ignore next */
-if (sharp) {
-  module.exports = sharp;
-} else {
-  const [isLinux, isMacOs, isWindows] = ['linux', 'darwin', 'win32'].map(os => runtimePlatform.startsWith(os));
-
-  const help = [`Could not load the "sharp" module using the ${runtimePlatform} runtime`];
-  errors.forEach(err => {
-    if (err.code !== 'MODULE_NOT_FOUND') {
-      help.push(`${err.code}: ${err.message}`);
-    }
-  });
-  const messages = errors.map(err => err.message).join(' ');
-  help.push('Possible solutions:');
-  // Common error messages
-  if (isUnsupportedNodeRuntime()) {
-    const { found, expected } = isUnsupportedNodeRuntime();
-    help.push(
-      '- Please upgrade Node.js:',
-      `    Found ${found}`,
-      `    Requires ${expected}`
-    );
-  } else if (prebuiltPlatforms.includes(runtimePlatform)) {
-    const [os, cpu] = runtimePlatform.split('-');
-    const libc = os.endsWith('musl') ? ' --libc=musl' : '';
-    help.push(
-      '- Ensure optional dependencies can be installed:',
-      '    npm install --include=optional sharp',
-      '- Ensure your package manager supports multi-platform installation:',
-      '    See https://sharp.pixelplumbing.com/install#cross-platform',
-      '- Add platform-specific dependencies:',
-      `    npm install --os=${os.replace('musl', '')}${libc} --cpu=${cpu} sharp`
-    );
-  } else {
-    help.push(
-      `- Manually install libvips >= ${minimumLibvipsVersion}`,
-      '- Add experimental WebAssembly-based dependencies:',
-      '    npm install --cpu=wasm32 sharp',
-      '    npm install @img/sharp-wasm32'
-    );
-  }
-  if (isLinux && /(symbol not found|CXXABI_)/i.test(messages)) {
-    try {
-      const { config } = require(`@img/sharp-libvips-${runtimePlatform}/package`);
-      const libcFound = `${familySync()} ${versionSync()}`;
-      const libcRequires = `${config.musl ? 'musl' : 'glibc'} ${config.musl || config.glibc}`;
-      help.push(
-        '- Update your OS:',
-        `    Found ${libcFound}`,
-        `    Requires ${libcRequires}`
-      );
-    } catch (errEngines) {}
-  }
-  if (isLinux && /\/snap\/core[0-9]{2}/.test(messages)) {
-    help.push(
-      '- Remove the Node.js Snap, which does not support native modules',
-      '    snap remove node'
-    );
-  }
-  if (isMacOs && /Incompatible library version/.test(messages)) {
-    help.push(
-      '- Update Homebrew:',
-      '    brew update && brew upgrade vips'
-    );
-  }
-  if (errors.some(err => err.code === 'ERR_DLOPEN_DISABLED')) {
-    help.push('- Run Node.js without using the --no-addons flag');
-  }
-  // Link to installation docs
-  if (isWindows && /The specified procedure could not be found/.test(messages)) {
-    help.push(
-      '- Using the canvas package on Windows?',
-      '    See https://sharp.pixelplumbing.com/install#canvas-and-windows',
-      '- Check for outdated versions of sharp in the dependency tree:',
-      '    npm ls sharp'
-    );
-  }
-  help.push(
-    '- Consult the installation documentation:',
-    '    See https://sharp.pixelplumbing.com/install'
-  );
-  throw new Error(help.join('\n'));
-}