sharp 0.30.0 → 0.30.1

package/README.md

@@ -1,6 +1,6 @@
 # sharp
 
-<img src="https://cdn.jsdelivr.net/gh/lovell/sharp@master/docs/image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
+<img src="https://cdn.jsdelivr.net/gh/lovell/sharp@main/docs/image/sharp-logo.svg" width="160" height="160" alt="sharp logo" align="right">
 
 The typical use case for this high speed Node.js module
 is to convert large images in common formats to
@@ -95,10 +95,10 @@ readableStream
 
 ## Contributing
 
-A [guide for contributors](https://github.com/lovell/sharp/blob/master/.github/CONTRIBUTING.md)
+A [guide for contributors](https://github.com/lovell/sharp/blob/main/.github/CONTRIBUTING.md)
 covers reporting bugs, requesting features and submitting code changes.
 
-[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=master)](https://coveralls.io/r/lovell/sharp?branch=master)
+[![Test Coverage](https://coveralls.io/repos/lovell/sharp/badge.svg?branch=main)](https://coveralls.io/r/lovell/sharp?branch=main)
 [![Node-API v5](https://img.shields.io/badge/Node--API-v5-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix)
 
 ## Licensing

package/lib/output.js

@@ -139,6 +139,7 @@ function toBuffer (options, callback) {
   } else if (this.options.resolveWithObject) {
     this.options.resolveWithObject = false;
   }
+  this.options.fileOut = '';
   return this._pipeline(is.fn(options) ? options : callback);
 }
 

package/lib/utility.js

@@ -30,11 +30,11 @@ const interpolators = {
   bilinear: 'bilinear',
   /** [Bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default). */
   bicubic: 'bicubic',
-  /** [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
+  /** [LBB interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/lbb.cpp#L100). Prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2. */
   locallyBoundedBicubic: 'lbb',
   /** [Nohalo interpolation](http://eprints.soton.ac.uk/268086/). Prevents acutance but typically reduces performance by a factor of 3. */
   nohalo: 'nohalo',
-  /** [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
+  /** [VSQBS interpolation](https://github.com/libvips/libvips/blob/master/libvips/resample/vsqbs.cpp#L48). Prevents "staircasing" when enlarging. */
   vertexSplitQuadraticBasisSpline: 'vsqbs'
 };
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -146,7 +146,7 @@
     "mocha": "^9.2.0",
     "mock-fs": "^5.1.2",
     "nyc": "^15.1.0",
-    "prebuild": "^11.0.2",
+    "prebuild": "^11.0.3",
     "rimraf": "^3.0.2",
     "semistandard": "^16.0.1"
   },

package/src/common.cc

@@ -885,7 +885,7 @@ namespace sharp {
   }
 
   std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
-    Canvas canvas, bool swap, bool withoutEnlargement) {
+    Canvas canvas, bool swap, bool withoutEnlargement, bool withoutReduction) {
     if (swap) {
       // Swap input width and height when requested.
       std::swap(width, height);
@@ -940,9 +940,14 @@ namespace sharp {
       }
     }
 
-    // We should not enlarge (oversample) the output image,
-    // if withoutEnlargement is specified.
-    if (withoutEnlargement) {
+    // We should not reduce or enlarge the output image, if
+    // withoutReduction or withoutEnlargement is specified.
+    if (withoutReduction) {
+      // Equivalent of VIPS_SIZE_UP
+      hshrink = std::min(1.0, hshrink);
+      vshrink = std::min(1.0, vshrink);
+    } else if (withoutEnlargement) {
+      // Equivalent of VIPS_SIZE_DOWN
       hshrink = std::max(1.0, hshrink);
       vshrink = std::max(1.0, vshrink);
     }

package/src/common.h

@@ -345,7 +345,7 @@ namespace sharp {
     the required thumbnail width/height and canvas mode.
   */
   std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
-    Canvas canvas, bool swap, bool withoutEnlargement);
+    Canvas canvas, bool swap, bool withoutEnlargement, bool withoutReduction);
 
 }  // namespace sharp
 

package/src/pipeline.cc

@@ -138,17 +138,6 @@ class PipelineWorker : public Napi::AsyncWorker {
         pageHeight = inputHeight;
       }
 
-      // If withoutReduction is specified,
-      // Override target width and height if less than respective value from input file
-       if (baton->withoutReduction) {
-          if (baton->width < inputWidth) {
-            baton->width = inputWidth;
-          }
-          if (baton->height < inputHeight) {
-            baton->height = inputHeight;
-          }
-      }
-
       // Scaling calculations
       double hshrink;
       double vshrink;
@@ -161,7 +150,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Shrink to pageHeight, so we work for multi-page images
       std::tie(hshrink, vshrink) = sharp::ResolveShrink(
         inputWidth, pageHeight, targetResizeWidth, targetResizeHeight,
-        baton->canvas, swap, baton->withoutEnlargement);
+        baton->canvas, swap, baton->withoutEnlargement, baton->withoutReduction);
 
       // The jpeg preload shrink.
       int jpegShrinkOnLoad = 1;
@@ -184,7 +173,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
         if (inputImageType == sharp::ImageType::JPEG) {
           // Leave at least a factor of two for the final resize step, when fastShrinkOnLoad: false
-          // for more consistent results and avoid occasional small image shifting
+          // for more consistent results and to avoid extra sharpness to the image
           int factor = baton->fastShrinkOnLoad ? 1 : 2;
           if (shrink >= 8 * factor) {
             jpegShrinkOnLoad = 8;
@@ -193,6 +182,10 @@ class PipelineWorker : public Napi::AsyncWorker {
           } else if (shrink >= 2 * factor) {
             jpegShrinkOnLoad = 2;
           }
+          // Lower shrink-on-load for known libjpeg rounding errors
+          if (jpegShrinkOnLoad > 1 && static_cast<int>(shrink) == jpegShrinkOnLoad) {
+            jpegShrinkOnLoad /= 2;
+          }
         } else if (inputImageType == sharp::ImageType::WEBP ||
                    inputImageType == sharp::ImageType::SVG ||
                    inputImageType == sharp::ImageType::PDF) {
@@ -270,35 +263,28 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Any pre-shrinking may already have been done
-      int thumbWidth = image.width();
-      int thumbHeight = image.height();
+      inputWidth = image.width();
+      inputHeight = image.height();
 
       // After pre-shrink, but before the main shrink stage
       // Reuse the initial pageHeight if we didn't pre-shrink
-      int preshrunkPageHeight = shouldPreShrink ? sharp::GetPageHeight(image) : pageHeight;
-
-      if (baton->fastShrinkOnLoad && jpegShrinkOnLoad > 1) {
-        // JPEG shrink-on-load rounds the output dimensions down, which
-        // may cause incorrect dimensions when fastShrinkOnLoad is enabled
-        // Just recalculate vshrink / hshrink on the main image instead of
-        // the pre-shrunk image when this is the case
-        hshrink = static_cast<double>(thumbWidth) / (static_cast<double>(inputWidth) / hshrink);
-        vshrink = static_cast<double>(preshrunkPageHeight) / (static_cast<double>(pageHeight) / vshrink);
-      } else {
-        // Shrink to preshrunkPageHeight, so we work for multi-page images
-        std::tie(hshrink, vshrink) = sharp::ResolveShrink(
-          thumbWidth, preshrunkPageHeight, targetResizeWidth, targetResizeHeight,
-          baton->canvas, swap, baton->withoutEnlargement);
+      if (shouldPreShrink) {
+        pageHeight = sharp::GetPageHeight(image);
       }
 
-      int targetHeight = static_cast<int>(std::rint(static_cast<double>(preshrunkPageHeight) / vshrink));
+      // Shrink to pageHeight, so we work for multi-page images
+      std::tie(hshrink, vshrink) = sharp::ResolveShrink(
+        inputWidth, pageHeight, targetResizeWidth, targetResizeHeight,
+        baton->canvas, swap, baton->withoutEnlargement, baton->withoutReduction);
+
+      int targetHeight = static_cast<int>(std::rint(static_cast<double>(pageHeight) / vshrink));
       int targetPageHeight = targetHeight;
 
       // In toilet-roll mode, we must adjust vshrink so that we exactly hit
-      // preshrunkPageHeight or we'll have pixels straddling pixel boundaries
-      if (thumbHeight > preshrunkPageHeight) {
+      // pageHeight or we'll have pixels straddling pixel boundaries
+      if (inputHeight > pageHeight) {
         targetHeight *= nPages;
-        vshrink = static_cast<double>(thumbHeight) / targetHeight;
+        vshrink = static_cast<double>(inputHeight) / targetHeight;
       }
 
       // Ensure we're using a device-independent colour space
@@ -532,12 +518,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         MultiPageUnsupported(nPages, "Affine");
         std::vector<double> background;
         std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground, shouldPremultiplyAlpha);
+        vips::VInterpolate interp = vips::VInterpolate::new_from_name(
+          const_cast<char*>(baton->affineInterpolator.data()));
         image = image.affine(baton->affineMatrix, VImage::option()->set("background", background)
           ->set("idx", baton->affineIdx)
           ->set("idy", baton->affineIdy)
           ->set("odx", baton->affineOdx)
           ->set("ody", baton->affineOdy)
-          ->set("interpolate", baton->affineInterpolator));
+          ->set("interpolate", interp));
       }
 
       // Extend edges
@@ -1442,7 +1430,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->affineIdy = sharp::AttrAsDouble(options, "affineIdy");
   baton->affineOdx = sharp::AttrAsDouble(options, "affineOdx");
   baton->affineOdy = sharp::AttrAsDouble(options, "affineOdy");
-  baton->affineInterpolator = vips::VInterpolate::new_from_name(sharp::AttrAsStr(options, "affineInterpolator").data());
+  baton->affineInterpolator = sharp::AttrAsStr(options, "affineInterpolator");
   baton->removeAlpha = sharp::AttrAsBool(options, "removeAlpha");
   baton->ensureAlpha = sharp::AttrAsDouble(options, "ensureAlpha");
   if (options.Has("boolean")) {

package/src/pipeline.h

@@ -126,7 +126,7 @@ struct PipelineBaton {
   double affineIdy;
   double affineOdx;
   double affineOdy;
-  vips::VInterpolate affineInterpolator;
+  std::string affineInterpolator;
   int jpegQuality;
   bool jpegProgressive;
   std::string jpegChromaSubsampling;
@@ -268,7 +268,7 @@ struct PipelineBaton {
     affineIdy(0),
     affineOdx(0),
     affineOdy(0),
-    affineInterpolator(vips::VInterpolate::new_from_name("bicubic")),
+    affineInterpolator("bicubic"),
     jpegQuality(80),
     jpegProgressive(false),
     jpegChromaSubsampling("4:2:0"),