sharp 0.29.0 → 0.30.0

package/lib/utility.js

@@ -1,9 +1,12 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const events = require('events');
 const detectLibc = require('detect-libc');
 
 const is = require('./is');
+const platformAndArch = require('./platform')();
 const sharp = require('./sharp');
 
 /**
@@ -45,8 +48,23 @@ let versions = {
   vips: sharp.libvipsVersion()
 };
 try {
-  versions = require(`../vendor/${versions.vips}/versions.json`);
-} catch (err) {}
+  versions = require(`../vendor/${versions.vips}/${platformAndArch}/versions.json`);
+} catch (_err) { /* ignore */ }
+
+/**
+ * An Object containing the platform and architecture
+ * of the current and installed vendored binaries.
+ * @member
+ * @example
+ * console.log(sharp.vendor);
+ */
+const vendor = {
+  current: platformAndArch,
+  installed: []
+};
+try {
+  vendor.installed = fs.readdirSync(path.join(__dirname, `../vendor/${versions.vips}`));
+} catch (_err) { /* ignore */ }
 
 /**
  * Gets or, when options are provided, sets the limits of _libvips'_ operation cache.
@@ -110,7 +128,7 @@ function concurrency (concurrency) {
   return sharp.concurrency(is.integer(concurrency) ? concurrency : null);
 }
 /* istanbul ignore next */
-if (detectLibc.family === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
+if (detectLibc.familySync() === detectLibc.GLIBC && !sharp._isUsingJemalloc()) {
   // Reduce default concurrency to 1 when using glibc memory allocator
   sharp.concurrency(1);
 }
@@ -175,5 +193,6 @@ module.exports = function (Sharp) {
   Sharp.format = format;
   Sharp.interpolators = interpolators;
   Sharp.versions = versions;
+  Sharp.vendor = vendor;
   Sharp.queue = queue;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sharp",
-  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, AVIF and TIFF images",
-  "version": "0.29.0",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
+  "version": "0.30.0",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://github.com/lovell/sharp",
   "contributors": [
@@ -78,7 +78,10 @@
     "Jacob Smith <jacob@frende.me>",
     "Michael Nutt <michael@nutt.im>",
     "Brad Parham <baparham@gmail.com>",
-    "Taneli Vatanen <taneli.vatanen@gmail.com>"
+    "Taneli Vatanen <taneli.vatanen@gmail.com>",
+    "Joris Dugué <zaruike10@gmail.com>",
+    "Chris Banks <christopher.bradley.banks@gmail.com>",
+    "Ompal Singh <ompal.hitm09@gmail.com>"
   ],
   "scripts": {
     "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node install/can-compile && node-gyp rebuild && node install/dll-copy)",
@@ -112,6 +115,7 @@
     "tiff",
     "gif",
     "svg",
+    "jp2",
     "dzi",
     "image",
     "resize",
@@ -122,33 +126,46 @@
     "vips"
   ],
   "dependencies": {
-    "color": "^4.0.1",
-    "detect-libc": "^1.0.3",
-    "node-addon-api": "^4.0.0",
-    "prebuild-install": "^6.1.4",
+    "color": "^4.2.0",
+    "detect-libc": "^2.0.0",
+    "node-addon-api": "^4.3.0",
+    "prebuild-install": "^7.0.1",
     "semver": "^7.3.5",
-    "simple-get": "^3.1.0",
+    "simple-get": "^4.0.1",
     "tar-fs": "^2.1.1",
     "tunnel-agent": "^0.6.0"
   },
   "devDependencies": {
-    "async": "^3.2.1",
+    "async": "^3.2.3",
     "cc": "^3.0.1",
     "decompress-zip": "^0.3.3",
     "documentation": "^13.2.5",
     "exif-reader": "^1.0.3",
     "icc": "^2.0.0",
     "license-checker": "^25.0.1",
-    "mocha": "^9.0.3",
-    "mock-fs": "^5.0.0",
+    "mocha": "^9.2.0",
+    "mock-fs": "^5.1.2",
     "nyc": "^15.1.0",
-    "prebuild": "^10.0.1",
+    "prebuild": "^11.0.2",
     "rimraf": "^3.0.2",
     "semistandard": "^16.0.1"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.11.3",
+    "libvips": "8.12.2",
+    "integrity": {
+      "darwin-arm64v8": "sha512-p46s/bbJAjkOXzPISZt9HUpG9GWjwQkYnLLRLKzsBJHLtB3X6C6Y/zXI5Hd0DOojcFkks9a0kTN+uDQ/XJY19g==",
+      "darwin-x64": "sha512-6vOHVZnvXwe6EXRsy29jdkUzBE6ElNpXUwd+m8vV7qy32AnXu7B9YemHsZ44vWviIwPZeXF6Nhd9EFLM0wWohw==",
+      "linux-arm64v8": "sha512-XwZdS63yhqLtbFtx/0eoLF/Agf5qtTrI11FMnMRpuBJWd4jHB60RAH+uzYUgoChCmKIS+AeXYMLm4d8Ns2QX8w==",
+      "linux-armv6": "sha512-Rh0Q0kqwPG2MjXWOkPCuPEyiUKFgKJYWLgS835D4MrXgdKr8Tft/eVrc2iGIxt2re30VpDiZ1h0Rby1aCZt2zw==",
+      "linux-armv7": "sha512-heTS/MsmRvu4JljINxP+vDiS9ZZfuGhr3IStb5F7Gc0/QLRhllYAg4rcO8L1eTK9sIIzG5ARvI19+YUZe7WbzA==",
+      "linux-x64": "sha512-SSWAwBFi0hx8V/h/v82tTFGKWTFv9FiCK3Timz5OExuI+sX1Ngrd0PVQaWXOThGNdel/fcD3Bz9YjSt4feBR1g==",
+      "linuxmusl-arm64v8": "sha512-Rhks+5C7p7aO6AucLT1uvzo8ohlqcqCUPgZmN+LZjsPWob/Iix3MfiDYtv/+gTvdeEfXxbCU6/YuPBwHQ7/crA==",
+      "linuxmusl-x64": "sha512-IOyjSQqpWVntqOUpCHVWuQwACwmmjdi15H8Pc+Ma1JkhPogTfVsFQWyL7DuOTD3Yr23EuYGzovUX00duOtfy/g==",
+      "win32-arm64v8": "sha512-A+Qe8Ipewtvw9ldvF6nWed2J8kphzrUE04nFeKCtNx6pfGQ/MAlCKMjt/U8VgUKNjB01zJDUW9XE0+FhGZ/UpQ==",
+      "win32-ia32": "sha512-cMrAvwFdDeAVnLJt0IPMPRKaIFhyXYGTprsM0DND9VUHE8F7dJMR44tS5YkXsGh1QNDtjKT6YuxAVUglmiXtpA==",
+      "win32-x64": "sha512-vLFIfw6aW2zABa8jpgzWDhljnE6glktrddErVyazAIoHl6BFFe/Da+LK1DbXvIYHz7fyOoKhSfCJHCiJG1Vg6w=="
+    },
     "runtime": "napi",
     "target": 5
   },

package/src/common.cc

@@ -132,6 +132,8 @@ namespace sharp {
     descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
     // Allow switch from random to sequential access
     descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+    // Remove safety features and allow unlimited SVG/PNG input
+    descriptor->unlimited = AttrAsBool(input, "unlimited");
     return descriptor;
   }
 
@@ -157,6 +159,10 @@ namespace sharp {
   bool IsGif(std::string const &str) {
     return EndsWith(str, ".gif") || EndsWith(str, ".GIF");
   }
+  bool IsJp2(std::string const &str) {
+    return EndsWith(str, ".jp2") || EndsWith(str, ".jpx") || EndsWith(str, ".j2k") || EndsWith(str, ".j2c")
+      || EndsWith(str, ".JP2") || EndsWith(str, ".JPX") || EndsWith(str, ".J2K") || EndsWith(str, ".J2C");
+  }
   bool IsTiff(std::string const &str) {
     return EndsWith(str, ".tif") || EndsWith(str, ".tiff") || EndsWith(str, ".TIF") || EndsWith(str, ".TIFF");
   }
@@ -190,6 +196,7 @@ namespace sharp {
       case ImageType::WEBP: id = "webp"; break;
       case ImageType::TIFF: id = "tiff"; break;
       case ImageType::GIF: id = "gif"; break;
+      case ImageType::JP2: id = "jp2"; break;
       case ImageType::SVG: id = "svg"; break;
       case ImageType::HEIF: id = "heif"; break;
       case ImageType::PDF: id = "pdf"; break;
@@ -226,6 +233,8 @@ namespace sharp {
     { "VipsForeignLoadGifBuffer", ImageType::GIF },
     { "VipsForeignLoadNsgifFile", ImageType::GIF },
     { "VipsForeignLoadNsgifBuffer", ImageType::GIF },
+    { "VipsForeignLoadJp2kBuffer", ImageType::JP2 },
+    { "VipsForeignLoadJp2kFile", ImageType::JP2 },
     { "VipsForeignLoadSvgFile", ImageType::SVG },
     { "VipsForeignLoadSvgBuffer", ImageType::SVG },
     { "VipsForeignLoadHeifFile", ImageType::HEIF },
@@ -234,6 +243,8 @@ namespace sharp {
     { "VipsForeignLoadPdfBuffer", ImageType::PDF },
     { "VipsForeignLoadMagickFile", ImageType::MAGICK },
     { "VipsForeignLoadMagickBuffer", ImageType::MAGICK },
+    { "VipsForeignLoadMagick7File", ImageType::MAGICK },
+    { "VipsForeignLoadMagick7Buffer", ImageType::MAGICK },
     { "VipsForeignLoadOpenslide", ImageType::OPENSLIDE },
     { "VipsForeignLoadPpmFile", ImageType::PPM },
     { "VipsForeignLoadFits", ImageType::FITS },
@@ -285,6 +296,7 @@ namespace sharp {
       imageType == ImageType::WEBP ||
       imageType == ImageType::MAGICK ||
       imageType == ImageType::GIF ||
+      imageType == ImageType::JP2 ||
       imageType == ImageType::TIFF ||
       imageType == ImageType::HEIF ||
       imageType == ImageType::PDF;
@@ -318,7 +330,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
-            if (imageType == ImageType::SVG) {
+            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -393,7 +405,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
-            if (imageType == ImageType::SVG) {
+            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -478,36 +490,41 @@ namespace sharp {
 
   /*
     Set animation properties if necessary.
-    Non-provided properties will be loaded from image.
   */
-  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop) {
-    bool hasDelay = delay.size() != 1 || delay.front() != -1;
-
-    if (pageHeight == 0 && image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
-      pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
-    }
+  VImage SetAnimationProperties(VImage image, int nPages, int pageHeight, std::vector<int> delay, int loop) {
+    bool hasDelay = !delay.empty();
 
-    if (!hasDelay && image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
-      delay = image.get_array_int("delay");
-      hasDelay = true;
-    }
+    // Avoid a copy if none of the animation properties are needed.
+    if (nPages == 1 && !hasDelay && loop == -1) return image;
 
-    if (loop == -1 && image.get_typeof("loop") == G_TYPE_INT) {
-      loop = image.get_int("loop");
+    if (delay.size() == 1) {
+      // We have just one delay, repeat that value for all frames.
+      delay.insert(delay.end(), nPages - 1, delay[0]);
     }
 
-    if (pageHeight == 0) return image;
-
-    // It is necessary to create the copy as otherwise, pageHeight will be ignored!
+    // Attaching metadata, need to copy the image.
     VImage copy = image.copy();
 
-    copy.set(VIPS_META_PAGE_HEIGHT, pageHeight);
+    // Only set page-height if we have more than one page, or this could
+    // accidentally turn into an animated image later.
+    if (nPages > 1) copy.set(VIPS_META_PAGE_HEIGHT, pageHeight);
     if (hasDelay) copy.set("delay", delay);
     if (loop != -1) copy.set("loop", loop);
 
     return copy;
   }
 
+  /*
+    Remove animation properties from image.
+  */
+  VImage RemoveAnimationProperties(VImage image) {
+    VImage copy = image.copy();
+    copy.remove(VIPS_META_PAGE_HEIGHT);
+    copy.remove("delay");
+    copy.remove("loop");
+    return copy;
+  }
+
   /*
     Does this image have a non-default density?
   */
@@ -533,6 +550,14 @@ namespace sharp {
     return copy;
   }
 
+  /*
+    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) {
+    return vips_image_get_page_height(image.get_image());
+  }
+
   /*
     Check the proposed format supports the current dimensions.
   */
@@ -589,6 +614,33 @@ namespace sharp {
     return warning;
   }
 
+  /*
+    Attach an event listener for progress updates, used to detect timeout
+  */
+  void SetTimeout(VImage image, int const seconds) {
+    if (seconds > 0) {
+      VipsImage *im = image.get_image();
+      if (im->progress_signal == NULL) {
+        int *timeout = VIPS_NEW(im, int);
+        *timeout = seconds;
+        g_signal_connect(im, "eval", G_CALLBACK(VipsProgressCallBack), timeout);
+        vips_image_set_progress(im, TRUE);
+      }
+    }
+  }
+
+  /*
+    Event listener for progress updates, used to detect timeout
+  */
+  void VipsProgressCallBack(VipsImage *im, VipsProgress *progress, int *timeout) {
+    // printf("VipsProgressCallBack progress=%d run=%d timeout=%d\n", progress->percent, progress->run, *timeout);
+    if (*timeout > 0 && progress->run >= *timeout) {
+      vips_image_set_kill(im, TRUE);
+      vips_error("timeout", "%d%% complete", progress->percent);
+      *timeout = 0;
+    }
+  }
+
   /*
     Calculate the (left, top) coordinates of the output image
     within the input image, applying the given gravity during an embed.
@@ -757,23 +809,27 @@ namespace sharp {
   /*
     Convert RGBA value to another colourspace
   */
-  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation) {
+  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba,
+    VipsInterpretation const interpretation, bool premultiply) {
     int const bands = static_cast<int>(rgba.size());
-    if (bands < 3 || interpretation == VIPS_INTERPRETATION_sRGB || interpretation == VIPS_INTERPRETATION_RGB) {
+    if (bands < 3) {
       return rgba;
-    } else {
-      VImage pixel = VImage::new_matrix(1, 1);
-      pixel.set("bands", bands);
-      pixel = pixel.new_from_image(rgba);
-      pixel = pixel.colourspace(interpretation, VImage::option()->set("source_space", VIPS_INTERPRETATION_sRGB));
-      return pixel(0, 0);
     }
+    VImage pixel = VImage::new_matrix(1, 1);
+    pixel.set("bands", bands);
+    pixel = pixel
+      .new_from_image(rgba)
+      .colourspace(interpretation, VImage::option()->set("source_space", VIPS_INTERPRETATION_sRGB));
+    if (premultiply) {
+      pixel = pixel.premultiply();
+    }
+    return pixel(0, 0);
   }
 
   /*
     Apply the alpha channel to a given colour
   */
-  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour) {
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour, bool premultiply) {
     // Scale up 8-bit values to match 16-bit input image
     double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
     // Create alphaColour colour
@@ -797,7 +853,7 @@ namespace sharp {
       alphaColour.push_back(colour[3] * multiplier);
     }
     // Ensure alphaColour colour uses correct colourspace
-    alphaColour = sharp::GetRgbaAsColourspace(alphaColour, image.interpretation());
+    alphaColour = sharp::GetRgbaAsColourspace(alphaColour, image.interpretation(), premultiply);
     // Add non-transparent alpha channel, if required
     if (colour[3] < 255.0 && !HasAlpha(image)) {
       image = image.bandjoin(
@@ -827,4 +883,75 @@ namespace sharp {
     }
     return image;
   }
+
+  std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
+    Canvas canvas, bool swap, bool withoutEnlargement) {
+    if (swap) {
+      // Swap input width and height when requested.
+      std::swap(width, height);
+    }
+
+    double hshrink = 1.0;
+    double vshrink = 1.0;
+
+    if (targetWidth > 0 && targetHeight > 0) {
+      // Fixed width and height
+      hshrink = static_cast<double>(width) / targetWidth;
+      vshrink = static_cast<double>(height) / targetHeight;
+
+      switch (canvas) {
+        case Canvas::CROP:
+        case Canvas::MIN:
+          if (hshrink < vshrink) {
+            vshrink = hshrink;
+          } else {
+            hshrink = vshrink;
+          }
+          break;
+        case Canvas::EMBED:
+        case Canvas::MAX:
+          if (hshrink > vshrink) {
+            vshrink = hshrink;
+          } else {
+            hshrink = vshrink;
+          }
+          break;
+        case Canvas::IGNORE_ASPECT:
+          if (swap) {
+            std::swap(hshrink, vshrink);
+          }
+          break;
+      }
+    } else if (targetWidth > 0) {
+      // Fixed width
+      hshrink = static_cast<double>(width) / targetWidth;
+
+      if (canvas != Canvas::IGNORE_ASPECT) {
+        // Auto height
+        vshrink = hshrink;
+      }
+    } else if (targetHeight > 0) {
+      // Fixed height
+      vshrink = static_cast<double>(height) / targetHeight;
+
+      if (canvas != Canvas::IGNORE_ASPECT) {
+        // Auto width
+        hshrink = vshrink;
+      }
+    }
+
+    // We should not enlarge (oversample) the output image,
+    // if withoutEnlargement is specified.
+    if (withoutEnlargement) {
+      hshrink = std::max(1.0, hshrink);
+      vshrink = std::max(1.0, vshrink);
+    }
+
+    // We don't want to shrink so much that we send an axis to 0
+    hshrink = std::min(hshrink, static_cast<double>(width));
+    vshrink = std::min(vshrink, static_cast<double>(height));
+
+    return std::make_pair(hshrink, vshrink);
+  }
+
 }  // namespace sharp

package/src/common.h

@@ -25,9 +25,9 @@
 // Verify platform and compiler compatibility
 
 #if (VIPS_MAJOR_VERSION < 8) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 11) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 11 && VIPS_MICRO_VERSION < 3)
-#error "libvips version 8.11.3+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 12) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 12 && VIPS_MICRO_VERSION < 2)
+#error "libvips version 8.12.2+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -50,6 +50,7 @@ namespace sharp {
     char *buffer;
     bool failOnError;
     int limitInputPixels;
+    bool unlimited;
     VipsAccess access;
     size_t bufferLength;
     bool isBuffer;
@@ -75,6 +76,7 @@ namespace sharp {
       buffer(nullptr),
       failOnError(TRUE),
       limitInputPixels(0x3FFF * 0x3FFF),
+      unlimited(FALSE),
       access(VIPS_ACCESS_RANDOM),
       bufferLength(0),
       isBuffer(FALSE),
@@ -116,6 +118,7 @@ namespace sharp {
     JPEG,
     PNG,
     WEBP,
+    JP2,
     TIFF,
     GIF,
     SVG,
@@ -132,6 +135,14 @@ namespace sharp {
     MISSING
   };
 
+  enum class Canvas {
+      CROP,
+      EMBED,
+      MAX,
+      MIN,
+      IGNORE_ASPECT
+  };
+
   // How many tasks are in the queue?
   extern volatile int counterQueue;
 
@@ -142,6 +153,7 @@ namespace sharp {
   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);
@@ -204,9 +216,13 @@ namespace sharp {
 
   /*
     Set animation properties if necessary.
-    Non-provided properties will be loaded from image.
   */
-  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop);
+  VImage SetAnimationProperties(VImage image, int nPages, int pageHeight, std::vector<int> delay, int loop);
+
+  /*
+    Remove animation properties from image.
+  */
+  VImage RemoveAnimationProperties(VImage image);
 
   /*
     Does this image have a non-default density?
@@ -223,6 +239,12 @@ namespace sharp {
   */
   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.
   */
@@ -243,6 +265,16 @@ namespace sharp {
   */
   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.
@@ -288,12 +320,13 @@ namespace sharp {
   /*
     Convert RGBA value to another colourspace
   */
-  std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation);
+  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);
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour, bool premultiply);
 
   /*
     Removes alpha channel, if any.
@@ -305,6 +338,15 @@ namespace sharp {
   */
   VImage EnsureAlpha(VImage image, double const value);
 
+  /*
+    Calculate the shrink factor, taking into account auto-rotate, the canvas
+    mode, and so on. The hshrink/vshrink are the amount to shrink the input
+    image axes by in order for the output axes (ie. after rotation) to match
+    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);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_