sharp 0.27.1 → 0.28.2

package/src/common.h

@@ -26,8 +26,8 @@
 
 #if (VIPS_MAJOR_VERSION < 8) || \
   (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 10) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 5)
-#error "libvips version 8.10.5+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 10 && VIPS_MICRO_VERSION < 6)
+#error "libvips version 8.10.6+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -57,9 +57,11 @@ namespace sharp {
     int rawChannels;
     int rawWidth;
     int rawHeight;
+    bool rawPremultiplied;
     int pages;
     int page;
     int level;
+    int subifd;
     int createChannels;
     int createWidth;
     int createHeight;
@@ -79,9 +81,11 @@ namespace sharp {
       rawChannels(0),
       rawWidth(0),
       rawHeight(0),
+      rawPremultiplied(false),
       pages(1),
       page(0),
       level(0),
+      subifd(-1),
       createChannels(0),
       createWidth(0),
       createHeight(0),
@@ -93,6 +97,7 @@ namespace sharp {
   // 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);
@@ -296,7 +301,7 @@ namespace sharp {
   /*
     Ensures alpha channel, if missing.
   */
-  VImage EnsureAlpha(VImage image);
+  VImage EnsureAlpha(VImage image, double const value);
 
 }  // namespace sharp
 

package/src/metadata.cc

@@ -86,6 +86,9 @@ class MetadataWorker : public Napi::AsyncWorker {
           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);
       // Derived attributes
       baton->hasAlpha = sharp::HasAlpha(image);
@@ -203,6 +206,9 @@ class MetadataWorker : public Napi::AsyncWorker {
         }
         info.Set("levels", levels);
       }
+      if (baton->subifds > 0) {
+        info.Set("subifds", baton->subifds);
+      }
       info.Set("hasProfile", baton->hasProfile);
       info.Set("hasAlpha", baton->hasAlpha);
       if (baton->orientation > 0) {

package/src/metadata.h

@@ -41,6 +41,7 @@ struct MetadataBaton {
   int pagePrimary;
   std::string compression;
   std::vector<std::pair<int, int>> levels;
+  int subifds;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -68,6 +69,7 @@ struct MetadataBaton {
     pageHeight(0),
     loop(-1),
     pagePrimary(-1),
+    subifds(0),
     hasProfile(false),
     hasAlpha(false),
     orientation(0),

package/src/operations.cc

@@ -149,8 +149,8 @@ namespace sharp {
    */
   VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix) {
     double *m = matrix.get();
+    image = image.colourspace(VIPS_INTERPRETATION_sRGB);
     return image
-      .colourspace(VIPS_INTERPRETATION_sRGB)
       .recomb(image.bands() == 3
         ? VImage::new_from_memory(
           m, 9 * sizeof(double), 3, 3, 1, VIPS_FORMAT_DOUBLE

package/src/pipeline.cc

@@ -226,7 +226,8 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (
         xshrink == yshrink && xshrink >= 2 * shrink_on_load_factor &&
         (inputImageType == sharp::ImageType::JPEG || inputImageType == sharp::ImageType::WEBP) &&
-        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0
+        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0 &&
+        image.width() > 3 && image.height() > 3
       ) {
         if (xshrink >= 8 * shrink_on_load_factor) {
           xfactor = xfactor / 8;
@@ -346,7 +347,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       bool const shouldModulate = baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0;
 
       if (shouldComposite && !sharp::HasAlpha(image)) {
-        image = sharp::EnsureAlpha(image);
+        image = sharp::EnsureAlpha(image, 1);
       }
 
       bool const shouldPremultiplyAlpha = sharp::HasAlpha(image) &&
@@ -562,9 +563,17 @@ class PipelineWorker : public Napi::AsyncWorker {
             // Use gravity in overlay
             if (compositeImage.width() <= baton->width) {
               across = static_cast<int>(ceil(static_cast<double>(image.width()) / compositeImage.width()));
+              // Ensure odd number of tiles across when gravity is centre, north or south
+              if (composite->gravity == 0 || composite->gravity == 1 || composite->gravity == 3) {
+                across |= 1;
+              }
             }
             if (compositeImage.height() <= baton->height) {
               down = static_cast<int>(ceil(static_cast<double>(image.height()) / compositeImage.height()));
+              // Ensure odd number of tiles down when gravity is centre, east or west
+              if (composite->gravity == 0 || composite->gravity == 2 || composite->gravity == 4) {
+                down |= 1;
+              }
             }
             if (across != 0 || down != 0) {
               int left;
@@ -586,7 +595,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Ensure image to composite is sRGB with premultiplied alpha
           compositeImage = compositeImage.colourspace(VIPS_INTERPRETATION_sRGB);
           if (!sharp::HasAlpha(compositeImage)) {
-            compositeImage = sharp::EnsureAlpha(compositeImage);
+            compositeImage = sharp::EnsureAlpha(compositeImage, 1);
           }
           if (!composite->premultiplied) compositeImage = compositeImage.premultiply();
           // Calculate position
@@ -594,8 +603,13 @@ class PipelineWorker : public Napi::AsyncWorker {
           int top;
           if (composite->hasOffset) {
             // Composite image at given offsets
-            std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
-              compositeImage.width(), compositeImage.height(), composite->left, composite->top);
+            if (composite->tile) {
+              std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
+                compositeImage.width(), compositeImage.height(), composite->left, composite->top);
+            } else {
+              left = composite->left;
+              top = composite->top;
+            }
           } else {
             // Composite image with given gravity
             std::tie(left, top) = sharp::CalculateCrop(image.width(), image.height(),
@@ -678,8 +692,8 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Ensure alpha channel, if missing
-      if (baton->ensureAlpha) {
-        image = sharp::EnsureAlpha(image);
+      if (baton->ensureAlpha != -1) {
+        image = sharp::EnsureAlpha(image, baton->ensureAlpha);
       }
 
       // Convert image to sRGB, if not already
@@ -704,11 +718,21 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("input_profile", "srgb")
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
       }
-
       // Override EXIF Orientation tag
       if (baton->withMetadata && baton->withMetadataOrientation != -1) {
         image = sharp::SetExifOrientation(image, baton->withMetadataOrientation);
       }
+      // Override pixel density
+      if (baton->withMetadataDensity > 0) {
+        image = sharp::SetDensity(image, baton->withMetadataDensity);
+      }
+      // Metadata key/value pairs, e.g. EXIF
+      if (!baton->withMetadataStrs.empty()) {
+        image = image.copy();
+        for (const auto& s : baton->withMetadataStrs) {
+          image.set(s.first.data(), s.second.data());
+        }
+      }
 
       // Number of channels used in output image
       baton->channels = image.bands();
@@ -1038,6 +1062,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("angle", CalculateAngleRotation(baton->tileAngle))
             ->set("background", baton->tileBackground)
             ->set("centre", baton->tileCentre)
+            ->set("id", const_cast<char*>(baton->tileId.data()))
             ->set("skip_blanks", baton->tileSkipBlanks);
           // libvips chooses a default depth based on layout. Instead of replicating that logic here by
           // not passing anything - libvips will handle choice
@@ -1327,7 +1352,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->affineInterpolator = vips::VInterpolate::new_from_name(sharp::AttrAsStr(options, "affineInterpolator").data());
 
   baton->removeAlpha = sharp::AttrAsBool(options, "removeAlpha");
-  baton->ensureAlpha = sharp::AttrAsBool(options, "ensureAlpha");
+  baton->ensureAlpha = sharp::AttrAsDouble(options, "ensureAlpha");
   if (options.Has("boolean")) {
     baton->boolean = sharp::CreateInputDescriptor(options.Get("boolean").As<Napi::Object>());
     baton->booleanOp = sharp::GetBooleanOperation(sharp::AttrAsStr(options, "booleanOp"));
@@ -1364,7 +1389,14 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->fileOut = sharp::AttrAsStr(options, "fileOut");
   baton->withMetadata = sharp::AttrAsBool(options, "withMetadata");
   baton->withMetadataOrientation = sharp::AttrAsUint32(options, "withMetadataOrientation");
+  baton->withMetadataDensity = sharp::AttrAsDouble(options, "withMetadataDensity");
   baton->withMetadataIcc = sharp::AttrAsStr(options, "withMetadataIcc");
+  Napi::Object mdStrs = options.Get("withMetadataStrs").As<Napi::Object>();
+  Napi::Array mdStrKeys = mdStrs.GetPropertyNames();
+  for (unsigned int i = 0; i < mdStrKeys.Length(); i++) {
+    std::string k = sharp::AttrAsStr(mdStrKeys, i);
+    baton->withMetadataStrs.insert(std::make_pair(k, sharp::AttrAsStr(mdStrs, k)));
+  }
   // Format-specific
   baton->jpegQuality = sharp::AttrAsUint32(options, "jpegQuality");
   baton->jpegProgressive = sharp::AttrAsBool(options, "jpegProgressive");
@@ -1438,6 +1470,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_DEPTH,
     sharp::AttrAsStr(options, "tileDepth").data()));
   baton->tileCentre = sharp::AttrAsBool(options, "tileCentre");
+  baton->tileId = sharp::AttrAsStr(options, "tileId");
 
   // Force random access for certain operations
   if (baton->input->access == VIPS_ACCESS_SEQUENTIAL) {

package/src/pipeline.h

@@ -18,6 +18,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <unordered_map>
 
 #include <napi.h>
 #include <vips/vips8>
@@ -167,7 +168,9 @@ struct PipelineBaton {
   std::string err;
   bool withMetadata;
   int withMetadataOrientation;
+  double withMetadataDensity;
   std::string withMetadataIcc;
+  std::unordered_map<std::string, std::string> withMetadataStrs;
   std::unique_ptr<double[]> convKernel;
   int convKernelWidth;
   int convKernelHeight;
@@ -178,7 +181,7 @@ struct PipelineBaton {
   VipsOperationBoolean bandBoolOp;
   int extractChannel;
   bool removeAlpha;
-  bool ensureAlpha;
+  double ensureAlpha;
   VipsInterpretation colourspace;
   int pageHeight;
   std::vector<int> delay;
@@ -192,6 +195,7 @@ struct PipelineBaton {
   std::vector<double> tileBackground;
   int tileSkipBlanks;
   VipsForeignDzDepth tileDepth;
+  std::string tileId;
   std::unique_ptr<double[]> recombMatrix;
 
   PipelineBaton():
@@ -258,7 +262,7 @@ struct PipelineBaton {
     jpegOptimiseScans(false),
     jpegOptimiseCoding(true),
     pngProgressive(false),
-    pngCompressionLevel(9),
+    pngCompressionLevel(6),
     pngAdaptiveFiltering(false),
     pngPalette(false),
     pngQuality(100),
@@ -287,6 +291,7 @@ struct PipelineBaton {
     heifLossless(false),
     withMetadata(false),
     withMetadataOrientation(-1),
+    withMetadataDensity(0.0),
     convKernelWidth(0),
     convKernelHeight(0),
     convKernelScale(0.0),
@@ -296,7 +301,7 @@ struct PipelineBaton {
     bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
     extractChannel(-1),
     removeAlpha(false),
-    ensureAlpha(false),
+    ensureAlpha(-1.0),
     colourspace(VIPS_INTERPRETATION_LAST),
     pageHeight(0),
     delay{-1},

package/src/sharp.cc

@@ -44,6 +44,7 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   exports.Set("libvipsVersion", Napi::Function::New(env, libvipsVersion));
   exports.Set("format", Napi::Function::New(env, format));
   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;
 }

package/src/utilities.cc

@@ -225,3 +225,19 @@ Napi::Value _maxColourDistance(const Napi::CallbackInfo& info) {
 
   return Napi::Number::New(env, maxColourDistance);
 }
+
+#if defined(__GNUC__)
+// mallctl will be resolved by the runtime linker when jemalloc is being used
+extern "C" {
+  int mallctl(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen) __attribute__((weak));
+}
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, mallctl != nullptr);
+}
+#else
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return Napi::Boolean::New(env, false);
+}
+#endif

package/src/utilities.h

@@ -24,5 +24,6 @@ Napi::Value simd(const Napi::CallbackInfo& info);
 Napi::Value libvipsVersion(const Napi::CallbackInfo& info);
 Napi::Value format(const Napi::CallbackInfo& info);
 Napi::Value _maxColourDistance(const Napi::CallbackInfo& info);
+Napi::Value _isUsingJemalloc(const Napi::CallbackInfo& info);
 
 #endif  // SRC_UTILITIES_H_