sharp 0.30.7 → 0.31.0

package/src/pipeline.cc

@@ -118,7 +118,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Trim
       if (baton->trimThreshold > 0.0) {
         MultiPageUnsupported(nPages, "Trim");
-        image = sharp::Trim(image, baton->trimThreshold);
+        image = sharp::Trim(image, baton->trimBackground, baton->trimThreshold);
         baton->trimOffsetLeft = image.xoffset();
         baton->trimOffsetTop = image.yoffset();
       }
@@ -204,6 +204,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         vips::VOption *option = VImage::option()
           ->set("access", baton->input->access)
           ->set("shrink", jpegShrinkOnLoad)
+          ->set("unlimited", baton->input->unlimited)
           ->set("fail_on", baton->input->failOn);
         if (baton->input->buffer != nullptr) {
           // Reload JPEG buffer
@@ -302,8 +303,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (
         sharp::HasProfile(image) &&
         image.interpretation() != VIPS_INTERPRETATION_LABS &&
-        image.interpretation() != VIPS_INTERPRETATION_GREY16 &&
-        image.interpretation() != VIPS_INTERPRETATION_B_W
+        image.interpretation() != VIPS_INTERPRETATION_GREY16
       ) {
         // Convert to sRGB/P3 using embedded profile
         try {
@@ -322,16 +322,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Flatten image to remove alpha channel
       if (baton->flatten && sharp::HasAlpha(image)) {
-        // Scale up 8-bit values to match 16-bit input image
-        double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
-        // Background colour
-        std::vector<double> background {
-          baton->flattenBackground[0] * multiplier,
-          baton->flattenBackground[1] * multiplier,
-          baton->flattenBackground[2] * multiplier
-        };
-        image = image.flatten(VImage::option()
-          ->set("background", background));
+        image = sharp::Flatten(image, baton->flattenBackground);
       }
 
       // Negate the colours in the image
@@ -353,11 +344,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       bool const shouldBlur = baton->blurSigma != 0.0;
       bool const shouldConv = baton->convKernelWidth * baton->convKernelHeight > 0;
       bool const shouldSharpen = baton->sharpenSigma != 0.0;
-      bool const shouldApplyMedian = baton->medianSize > 0;
       bool const shouldComposite = !baton->composite.empty();
-      bool const shouldModulate = baton->brightness != 1.0 || baton->saturation != 1.0 ||
-                                  baton->hue != 0.0 || baton->lightness != 0.0;
-      bool const shouldApplyClahe = baton->claheWidth != 0 && baton->claheHeight != 0;
 
       if (shouldComposite && !sharp::HasAlpha(image)) {
         image = sharp::EnsureAlpha(image, 1);
@@ -366,26 +353,27 @@ class PipelineWorker : public Napi::AsyncWorker {
       bool const shouldPremultiplyAlpha = sharp::HasAlpha(image) &&
         (shouldResize || shouldBlur || shouldConv || shouldSharpen);
 
-      // Premultiply image alpha channel before all transformations to avoid
-      // dark fringing around bright pixels
-      // See: http://entropymine.com/imageworsener/resizealpha/
       if (shouldPremultiplyAlpha) {
         image = image.premultiply();
       }
 
       // Resize
       if (shouldResize) {
-        VipsKernel kernel = static_cast<VipsKernel>(
-          vips_enum_from_nick(nullptr, VIPS_TYPE_KERNEL, baton->kernel.data()));
-        if (
-          kernel != VIPS_KERNEL_NEAREST && kernel != VIPS_KERNEL_CUBIC && kernel != VIPS_KERNEL_LANCZOS2 &&
-          kernel != VIPS_KERNEL_LANCZOS3 && kernel != VIPS_KERNEL_MITCHELL
-        ) {
-          throw vips::VError("Unknown kernel");
-        }
         image = image.resize(1.0 / hshrink, VImage::option()
           ->set("vscale", 1.0 / vshrink)
-          ->set("kernel", kernel));
+          ->set("kernel", baton->kernel));
+      }
+
+      // Flip (mirror about Y axis)
+      if (baton->flip || flip) {
+        image = image.flip(VIPS_DIRECTION_VERTICAL);
+        image = sharp::RemoveExifOrientation(image);
+      }
+
+      // Flop (mirror about X axis)
+      if (baton->flop || flop) {
+        image = image.flip(VIPS_DIRECTION_HORIZONTAL);
+        image = sharp::RemoveExifOrientation(image);
       }
 
       // Rotate post-extract 90-angle
@@ -402,18 +390,6 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::RemoveExifOrientation(image);
       }
 
-      // Flip (mirror about Y axis)
-      if (baton->flip || flip) {
-        image = image.flip(VIPS_DIRECTION_VERTICAL);
-        image = sharp::RemoveExifOrientation(image);
-      }
-
-      // Flop (mirror about X axis)
-      if (baton->flop || flop) {
-        image = image.flip(VIPS_DIRECTION_HORIZONTAL);
-        image = sharp::RemoveExifOrientation(image);
-      }
-
       // Join additional color channels to the image
       if (baton->joinChannelIn.size() > 0) {
         VImage joinImage;
@@ -445,18 +421,12 @@ class PipelineWorker : public Napi::AsyncWorker {
           std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground, shouldPremultiplyAlpha);
 
           // Embed
-
-          // Calculate where to position the embedded image if gravity specified, else center.
           int left;
           int top;
-
-          left = static_cast<int>(round((baton->width - inputWidth) / 2));
-          top = static_cast<int>(round((baton->height - inputHeight) / 2));
-
-          int width = std::max(inputWidth, baton->width);
-          int height = std::max(inputHeight, baton->height);
           std::tie(left, top) = sharp::CalculateEmbedPosition(
             inputWidth, inputHeight, baton->width, baton->height, baton->position);
+          int width = std::max(inputWidth, baton->width);
+          int height = std::max(inputHeight, baton->height);
 
           image = nPages > 1
             ? sharp::EmbedMultiPage(image,
@@ -555,7 +525,7 @@ class PipelineWorker : public Napi::AsyncWorker {
               VImage::option()->set("extend", VIPS_EXTEND_BACKGROUND)->set("background", background));
       }
       // Median - must happen before blurring, due to the utility of blurring after thresholding
-      if (shouldApplyMedian) {
+      if (baton->medianSize > 0) {
         image = image.median(baton->medianSize);
       }
       // Threshold - must happen before blurring, due to the utility of blurring after thresholding
@@ -581,7 +551,8 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::Recomb(image, baton->recombMatrix);
       }
 
-      if (shouldModulate) {
+      // Modulate
+      if (baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0 || baton->lightness != 0.0) {
         image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue, baton->lightness);
       }
 
@@ -591,6 +562,18 @@ class PipelineWorker : public Napi::AsyncWorker {
           baton->sharpenX1, baton->sharpenY2, baton->sharpenY3);
       }
 
+      // Reverse premultiplication after all transformations
+      if (shouldPremultiplyAlpha) {
+        image = image.unpremultiply();
+        // Cast pixel values to integer
+        if (sharp::Is16Bit(image.interpretation())) {
+          image = image.cast(VIPS_FORMAT_USHORT);
+        } else {
+          image = image.cast(VIPS_FORMAT_UCHAR);
+        }
+      }
+      baton->premultiplied = shouldPremultiplyAlpha;
+
       // Composite
       if (shouldComposite) {
         std::vector<VImage> images = { image };
@@ -668,28 +651,16 @@ class PipelineWorker : public Napi::AsyncWorker {
           xs.push_back(left);
           ys.push_back(top);
         }
-        image = image.composite(images, modes, VImage::option()->set("x", xs)->set("y", ys));
+        image = VImage::composite(images, modes, VImage::option()->set("x", xs)->set("y", ys));
       }
 
-      // Reverse premultiplication after all transformations:
-      if (shouldPremultiplyAlpha) {
-        image = image.unpremultiply();
-        // Cast pixel values to integer
-        if (sharp::Is16Bit(image.interpretation())) {
-          image = image.cast(VIPS_FORMAT_USHORT);
-        } else {
-          image = image.cast(VIPS_FORMAT_UCHAR);
-        }
-      }
-      baton->premultiplied = shouldPremultiplyAlpha;
-
       // Gamma decoding (brighten)
       if (baton->gammaOut >= 1 && baton->gammaOut <= 3) {
         image = sharp::Gamma(image, baton->gammaOut);
       }
 
       // Linear adjustment (a * in + b)
-      if (baton->linearA != 1.0 || baton->linearB != 0.0) {
+      if (!baton->linearA.empty()) {
         image = sharp::Linear(image, baton->linearA, baton->linearB);
       }
 
@@ -699,7 +670,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Apply contrast limiting adaptive histogram equalization (CLAHE)
-      if (shouldApplyClahe) {
+      if (baton->claheWidth != 0 && baton->claheHeight != 0) {
         image = sharp::Clahe(image, baton->claheWidth, baton->claheHeight, baton->claheMaxSlope);
       }
 
@@ -873,6 +844,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("near_lossless", baton->webpNearLossless)
             ->set("smart_subsample", baton->webpSmartSubsample)
             ->set("effort", baton->webpEffort)
+            ->set("min_size", baton->webpMinSize)
+            ->set("mixed", baton->webpMixed)
             ->set("alpha_q", baton->webpAlphaQuality)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -887,6 +860,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("strip", !baton->withMetadata)
             ->set("bitdepth", baton->gifBitdepth)
             ->set("effort", baton->gifEffort)
+            ->set("reoptimise", baton->gifReoptimise)
             ->set("dither", baton->gifDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -939,6 +913,19 @@ class PipelineWorker : public Napi::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "heif";
+        } else if (baton->formatOut == "dz") {
+          // Write DZ to buffer
+          baton->tileContainer = VIPS_FOREIGN_DZ_CONTAINER_ZIP;
+          if (!sharp::HasAlpha(image)) {
+            baton->tileBackground.pop_back();
+          }
+          vips::VOption *options = BuildOptionsDZ(baton);
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.dzsave_buffer(options));
+          baton->bufferOut = static_cast<char*>(area->data);
+          baton->bufferOutLength = area->length;
+          area->free_fn = nullptr;
+          vips_area_unref(area);
+          baton->formatOut = "dz";
         } else if (baton->formatOut == "raw" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::RAW)) {
           // Write raw, uncompressed image data to buffer
@@ -1040,6 +1027,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("near_lossless", baton->webpNearLossless)
             ->set("smart_subsample", baton->webpSmartSubsample)
             ->set("effort", baton->webpEffort)
+            ->set("min_size", baton->webpMinSize)
+            ->set("mixed", baton->webpMixed)
             ->set("alpha_q", baton->webpAlphaQuality));
           baton->formatOut = "webp";
         } else if (baton->formatOut == "gif" || (mightMatchInput && isGif) ||
@@ -1050,6 +1039,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("strip", !baton->withMetadata)
             ->set("bitdepth", baton->gifBitdepth)
             ->set("effort", baton->gifEffort)
+            ->set("reoptimise", baton->gifReoptimise)
             ->set("dither", baton->gifDither));
           baton->formatOut = "gif";
         } else if (baton->formatOut == "tiff" || (mightMatchInput && isTiff) ||
@@ -1091,64 +1081,14 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("lossless", baton->heifLossless));
           baton->formatOut = "heif";
         } else if (baton->formatOut == "dz" || isDz || isDzZip) {
+          // Write DZ to file
           if (isDzZip) {
             baton->tileContainer = VIPS_FOREIGN_DZ_CONTAINER_ZIP;
           }
-          // Forward format options through suffix
-          std::string suffix;
-          if (baton->tileFormat == "png") {
-            std::vector<std::pair<std::string, std::string>> options {
-              {"interlace", baton->pngProgressive ? "TRUE" : "FALSE"},
-              {"compression", std::to_string(baton->pngCompressionLevel)},
-              {"filter", baton->pngAdaptiveFiltering ? "all" : "none"}
-            };
-            suffix = AssembleSuffixString(".png", options);
-          } else if (baton->tileFormat == "webp") {
-            std::vector<std::pair<std::string, std::string>> options {
-              {"Q", std::to_string(baton->webpQuality)},
-              {"alpha_q", std::to_string(baton->webpAlphaQuality)},
-              {"lossless", baton->webpLossless ? "TRUE" : "FALSE"},
-              {"near_lossless", baton->webpNearLossless ? "TRUE" : "FALSE"},
-              {"smart_subsample", baton->webpSmartSubsample ? "TRUE" : "FALSE"},
-              {"effort", std::to_string(baton->webpEffort)}
-            };
-            suffix = AssembleSuffixString(".webp", options);
-          } else {
-            std::vector<std::pair<std::string, std::string>> options {
-              {"Q", std::to_string(baton->jpegQuality)},
-              {"interlace", baton->jpegProgressive ? "TRUE" : "FALSE"},
-              {"subsample_mode", baton->jpegChromaSubsampling == "4:4:4" ? "off" : "on"},
-              {"trellis_quant", baton->jpegTrellisQuantisation ? "TRUE" : "FALSE"},
-              {"quant_table", std::to_string(baton->jpegQuantisationTable)},
-              {"overshoot_deringing", baton->jpegOvershootDeringing ? "TRUE": "FALSE"},
-              {"optimize_scans", baton->jpegOptimiseScans ? "TRUE": "FALSE"},
-              {"optimize_coding", baton->jpegOptimiseCoding ? "TRUE": "FALSE"}
-            };
-            std::string extname = baton->tileLayout == VIPS_FOREIGN_DZ_LAYOUT_DZ ? ".jpeg" : ".jpg";
-            suffix = AssembleSuffixString(extname, options);
-          }
-          // Remove alpha channel from tile background if image does not contain an alpha channel
           if (!sharp::HasAlpha(image)) {
             baton->tileBackground.pop_back();
           }
-          // Write DZ to file
-          vips::VOption *options = VImage::option()
-            ->set("strip", !baton->withMetadata)
-            ->set("tile_size", baton->tileSize)
-            ->set("overlap", baton->tileOverlap)
-            ->set("container", baton->tileContainer)
-            ->set("layout", baton->tileLayout)
-            ->set("suffix", const_cast<char*>(suffix.data()))
-            ->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
-          if (baton->tileDepth < VIPS_FOREIGN_DZ_DEPTH_LAST) {
-            options->set("depth", baton->tileDepth);
-          }
+          vips::VOption *options = BuildOptionsDZ(baton);
           image.dzsave(const_cast<char*>(baton->fileOut.data()), options);
           baton->formatOut = "dz";
         } else if (baton->formatOut == "v" || (mightMatchInput && isV) ||
@@ -1217,6 +1157,10 @@ class PipelineWorker : public Napi::AsyncWorker {
         info.Set("trimOffsetTop", static_cast<int32_t>(baton->trimOffsetTop));
       }
 
+      if (baton->input->textAutofitDpi) {
+        info.Set("textAutofitDpi", static_cast<uint32_t>(baton->input->textAutofitDpi));
+      }
+
       if (baton->bufferOutLength > 0) {
         // Add buffer size to info
         info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));
@@ -1305,7 +1249,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
   /*
     Assemble the suffix argument to dzsave, which is the format (by extname)
-    alongisde comma-separated arguments to the corresponding `formatsave` vips
+    alongside comma-separated arguments to the corresponding `formatsave` vips
     action.
   */
   std::string
@@ -1320,6 +1264,67 @@ class PipelineWorker : public Napi::AsyncWorker {
     return extname + "[" + argument + "]";
   }
 
+  /*
+    Build VOption for dzsave
+  */
+  vips::VOption*
+  BuildOptionsDZ(PipelineBaton *baton) {
+    // Forward format options through suffix
+    std::string suffix;
+    if (baton->tileFormat == "png") {
+      std::vector<std::pair<std::string, std::string>> options {
+        {"interlace", baton->pngProgressive ? "TRUE" : "FALSE"},
+        {"compression", std::to_string(baton->pngCompressionLevel)},
+        {"filter", baton->pngAdaptiveFiltering ? "all" : "none"}
+      };
+      suffix = AssembleSuffixString(".png", options);
+    } else if (baton->tileFormat == "webp") {
+      std::vector<std::pair<std::string, std::string>> options {
+        {"Q", std::to_string(baton->webpQuality)},
+        {"alpha_q", std::to_string(baton->webpAlphaQuality)},
+        {"lossless", baton->webpLossless ? "TRUE" : "FALSE"},
+        {"near_lossless", baton->webpNearLossless ? "TRUE" : "FALSE"},
+        {"smart_subsample", baton->webpSmartSubsample ? "TRUE" : "FALSE"},
+        {"min_size", baton->webpMinSize ? "TRUE" : "FALSE"},
+        {"mixed", baton->webpMixed ? "TRUE" : "FALSE"},
+        {"effort", std::to_string(baton->webpEffort)}
+      };
+      suffix = AssembleSuffixString(".webp", options);
+    } else {
+      std::vector<std::pair<std::string, std::string>> options {
+        {"Q", std::to_string(baton->jpegQuality)},
+        {"interlace", baton->jpegProgressive ? "TRUE" : "FALSE"},
+        {"subsample_mode", baton->jpegChromaSubsampling == "4:4:4" ? "off" : "on"},
+        {"trellis_quant", baton->jpegTrellisQuantisation ? "TRUE" : "FALSE"},
+        {"quant_table", std::to_string(baton->jpegQuantisationTable)},
+        {"overshoot_deringing", baton->jpegOvershootDeringing ? "TRUE": "FALSE"},
+        {"optimize_scans", baton->jpegOptimiseScans ? "TRUE": "FALSE"},
+        {"optimize_coding", baton->jpegOptimiseCoding ? "TRUE": "FALSE"}
+      };
+      std::string extname = baton->tileLayout == VIPS_FOREIGN_DZ_LAYOUT_DZ ? ".jpeg" : ".jpg";
+      suffix = AssembleSuffixString(extname, options);
+    }
+    vips::VOption *options = VImage::option()
+      ->set("strip", !baton->withMetadata)
+      ->set("tile_size", baton->tileSize)
+      ->set("overlap", baton->tileOverlap)
+      ->set("container", baton->tileContainer)
+      ->set("layout", baton->tileLayout)
+      ->set("suffix", const_cast<char*>(suffix.data()))
+      ->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);
+    if (baton->tileDepth < VIPS_FOREIGN_DZ_DEPTH_LAST) {
+      options->set("depth", baton->tileDepth);
+    }
+    if (!baton->tileBasename.empty()) {
+      options->set("basename", const_cast<char*>(baton->tileBasename.data()));
+    }
+    return options;
+  }
+
   /*
     Clear all thread-local data.
   */
@@ -1365,17 +1370,13 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   } else if (canvas == "ignore_aspect") {
     baton->canvas = sharp::Canvas::IGNORE_ASPECT;
   }
-  // Tint chroma
-  baton->tintA = sharp::AttrAsDouble(options, "tintA");
-  baton->tintB = sharp::AttrAsDouble(options, "tintB");
   // Composite
   Napi::Array compositeArray = options.Get("composite").As<Napi::Array>();
   for (unsigned int i = 0; i < compositeArray.Length(); i++) {
     Napi::Object compositeObject = compositeArray.Get(i).As<Napi::Object>();
     Composite *composite = new Composite;
     composite->input = sharp::CreateInputDescriptor(compositeObject.Get("input").As<Napi::Object>());
-    composite->mode = static_cast<VipsBlendMode>(
-      vips_enum_from_nick(nullptr, VIPS_TYPE_BLEND_MODE, sharp::AttrAsStr(compositeObject, "blend").data()));
+    composite->mode = sharp::AttrAsEnum<VipsBlendMode>(compositeObject, "blend", VIPS_TYPE_BLEND_MODE);
     composite->gravity = sharp::AttrAsUint32(compositeObject, "gravity");
     composite->left = sharp::AttrAsInt32(compositeObject, "left");
     composite->top = sharp::AttrAsInt32(compositeObject, "top");
@@ -1389,7 +1390,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->withoutReduction = sharp::AttrAsBool(options, "withoutReduction");
   baton->position = sharp::AttrAsInt32(options, "position");
   baton->resizeBackground = sharp::AttrAsVectorOfDouble(options, "resizeBackground");
-  baton->kernel = sharp::AttrAsStr(options, "kernel");
+  baton->kernel = sharp::AttrAsEnum<VipsKernel>(options, "kernel", VIPS_TYPE_KERNEL);
   baton->fastShrinkOnLoad = sharp::AttrAsBool(options, "fastShrinkOnLoad");
   // Join Channel Options
   if (options.Has("joinChannelIn")) {
@@ -1418,13 +1419,16 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->sharpenY3 = sharp::AttrAsDouble(options, "sharpenY3");
   baton->threshold = sharp::AttrAsInt32(options, "threshold");
   baton->thresholdGrayscale = sharp::AttrAsBool(options, "thresholdGrayscale");
+  baton->trimBackground = sharp::AttrAsVectorOfDouble(options, "trimBackground");
   baton->trimThreshold = sharp::AttrAsDouble(options, "trimThreshold");
   baton->gamma = sharp::AttrAsDouble(options, "gamma");
   baton->gammaOut = sharp::AttrAsDouble(options, "gammaOut");
-  baton->linearA = sharp::AttrAsDouble(options, "linearA");
-  baton->linearB = sharp::AttrAsDouble(options, "linearB");
+  baton->linearA = sharp::AttrAsVectorOfDouble(options, "linearA");
+  baton->linearB = sharp::AttrAsVectorOfDouble(options, "linearB");
   baton->greyscale = sharp::AttrAsBool(options, "greyscale");
   baton->normalise = sharp::AttrAsBool(options, "normalise");
+  baton->tintA = sharp::AttrAsDouble(options, "tintA");
+  baton->tintB = sharp::AttrAsDouble(options, "tintB");
   baton->claheWidth = sharp::AttrAsUint32(options, "claheWidth");
   baton->claheHeight = sharp::AttrAsUint32(options, "claheHeight");
   baton->claheMaxSlope = sharp::AttrAsUint32(options, "claheMaxSlope");
@@ -1452,10 +1456,10 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   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"));
+    baton->booleanOp = sharp::AttrAsEnum<VipsOperationBoolean>(options, "booleanOp", VIPS_TYPE_OPERATION_BOOLEAN);
   }
   if (options.Has("bandBoolOp")) {
-    baton->bandBoolOp = sharp::GetBooleanOperation(sharp::AttrAsStr(options, "bandBoolOp"));
+    baton->bandBoolOp = sharp::AttrAsEnum<VipsOperationBoolean>(options, "bandBoolOp", VIPS_TYPE_OPERATION_BOOLEAN);
   }
   if (options.Has("convKernel")) {
     Napi::Object kernel = options.Get("convKernel").As<Napi::Object>();
@@ -1477,11 +1481,12 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
        baton->recombMatrix[i] = sharp::AttrAsDouble(recombMatrix, i);
     }
   }
-  baton->colourspaceInput = sharp::GetInterpretation(sharp::AttrAsStr(options, "colourspaceInput"));
+  baton->colourspaceInput = sharp::AttrAsEnum<VipsInterpretation>(
+    options, "colourspaceInput", VIPS_TYPE_INTERPRETATION);
   if (baton->colourspaceInput == VIPS_INTERPRETATION_ERROR) {
     baton->colourspaceInput = VIPS_INTERPRETATION_LAST;
   }
-  baton->colourspace = sharp::GetInterpretation(sharp::AttrAsStr(options, "colourspace"));
+  baton->colourspace = sharp::AttrAsEnum<VipsInterpretation>(options, "colourspace", VIPS_TYPE_INTERPRETATION);
   if (baton->colourspace == VIPS_INTERPRETATION_ERROR) {
     baton->colourspace = VIPS_INTERPRETATION_sRGB;
   }
@@ -1496,7 +1501,9 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   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)));
+    if (mdStrs.HasOwnProperty(k)) {
+      baton->withMetadataStrs.insert(std::make_pair(k, sharp::AttrAsStr(mdStrs, k)));
+    }
   }
   baton->timeoutSeconds = sharp::AttrAsUint32(options, "timeoutSeconds");
   // Format-specific
@@ -1527,9 +1534,12 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->webpNearLossless = sharp::AttrAsBool(options, "webpNearLossless");
   baton->webpSmartSubsample = sharp::AttrAsBool(options, "webpSmartSubsample");
   baton->webpEffort = sharp::AttrAsUint32(options, "webpEffort");
+  baton->webpMinSize = sharp::AttrAsBool(options, "webpMinSize");
+  baton->webpMixed = sharp::AttrAsBool(options, "webpMixed");
   baton->gifBitdepth = sharp::AttrAsUint32(options, "gifBitdepth");
   baton->gifEffort = sharp::AttrAsUint32(options, "gifEffort");
   baton->gifDither = sharp::AttrAsDouble(options, "gifDither");
+  baton->gifReoptimise = sharp::AttrAsBool(options, "gifReoptimise");
   baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");
   baton->tiffPyramid = sharp::AttrAsBool(options, "tiffPyramid");
   baton->tiffBitdepth = sharp::AttrAsUint32(options, "tiffBitdepth");
@@ -1541,28 +1551,19 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   if (baton->tiffXres == 1.0 && baton->tiffYres == 1.0 && baton->withMetadataDensity > 0) {
     baton->tiffXres = baton->tiffYres = baton->withMetadataDensity / 25.4;
   }
-  // tiff compression options
-  baton->tiffCompression = static_cast<VipsForeignTiffCompression>(
-  vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_COMPRESSION,
-    sharp::AttrAsStr(options, "tiffCompression").data()));
-  baton->tiffPredictor = static_cast<VipsForeignTiffPredictor>(
-  vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_PREDICTOR,
-    sharp::AttrAsStr(options, "tiffPredictor").data()));
-  baton->tiffResolutionUnit = static_cast<VipsForeignTiffResunit>(
-  vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_RESUNIT,
-    sharp::AttrAsStr(options, "tiffResolutionUnit").data()));
-
+  baton->tiffCompression = sharp::AttrAsEnum<VipsForeignTiffCompression>(
+    options, "tiffCompression", VIPS_TYPE_FOREIGN_TIFF_COMPRESSION);
+  baton->tiffPredictor = sharp::AttrAsEnum<VipsForeignTiffPredictor>(
+    options, "tiffPredictor", VIPS_TYPE_FOREIGN_TIFF_PREDICTOR);
+  baton->tiffResolutionUnit = sharp::AttrAsEnum<VipsForeignTiffResunit>(
+    options, "tiffResolutionUnit", VIPS_TYPE_FOREIGN_TIFF_RESUNIT);
   baton->heifQuality = sharp::AttrAsUint32(options, "heifQuality");
   baton->heifLossless = sharp::AttrAsBool(options, "heifLossless");
-  baton->heifCompression = static_cast<VipsForeignHeifCompression>(
-    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_HEIF_COMPRESSION,
-    sharp::AttrAsStr(options, "heifCompression").data()));
+  baton->heifCompression = sharp::AttrAsEnum<VipsForeignHeifCompression>(
+    options, "heifCompression", VIPS_TYPE_FOREIGN_HEIF_COMPRESSION);
   baton->heifEffort = sharp::AttrAsUint32(options, "heifEffort");
   baton->heifChromaSubsampling = sharp::AttrAsStr(options, "heifChromaSubsampling");
-  // Raw output
-  baton->rawDepth = static_cast<VipsBandFormat>(
-    vips_enum_from_nick(nullptr, VIPS_TYPE_BAND_FORMAT,
-    sharp::AttrAsStr(options, "rawDepth").data()));
+  baton->rawDepth = sharp::AttrAsEnum<VipsBandFormat>(options, "rawDepth", VIPS_TYPE_BAND_FORMAT);
   // Animated output properties
   if (sharp::HasAttr(options, "loop")) {
     baton->loop = sharp::AttrAsUint32(options, "loop");
@@ -1570,24 +1571,19 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   if (sharp::HasAttr(options, "delay")) {
     baton->delay = sharp::AttrAsInt32Vector(options, "delay");
   }
-  // Tile output
   baton->tileSize = sharp::AttrAsUint32(options, "tileSize");
   baton->tileOverlap = sharp::AttrAsUint32(options, "tileOverlap");
   baton->tileAngle = sharp::AttrAsInt32(options, "tileAngle");
   baton->tileBackground = sharp::AttrAsVectorOfDouble(options, "tileBackground");
   baton->tileSkipBlanks = sharp::AttrAsInt32(options, "tileSkipBlanks");
-  baton->tileContainer = static_cast<VipsForeignDzContainer>(
-    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_CONTAINER,
-    sharp::AttrAsStr(options, "tileContainer").data()));
-  baton->tileLayout = static_cast<VipsForeignDzLayout>(
-    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_LAYOUT,
-    sharp::AttrAsStr(options, "tileLayout").data()));
+  baton->tileContainer = sharp::AttrAsEnum<VipsForeignDzContainer>(
+    options, "tileContainer", VIPS_TYPE_FOREIGN_DZ_CONTAINER);
+  baton->tileLayout = sharp::AttrAsEnum<VipsForeignDzLayout>(options, "tileLayout", VIPS_TYPE_FOREIGN_DZ_LAYOUT);
   baton->tileFormat = sharp::AttrAsStr(options, "tileFormat");
-  baton->tileDepth = static_cast<VipsForeignDzDepth>(
-    vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_DZ_DEPTH,
-    sharp::AttrAsStr(options, "tileDepth").data()));
+  baton->tileDepth = sharp::AttrAsEnum<VipsForeignDzDepth>(options, "tileDepth", VIPS_TYPE_FOREIGN_DZ_DEPTH);
   baton->tileCentre = sharp::AttrAsBool(options, "tileCentre");
   baton->tileId = sharp::AttrAsStr(options, "tileId");
+  baton->tileBasename = sharp::AttrAsStr(options, "tileBasename");
 
   // Force random access for certain operations
   if (baton->input->access == VIPS_ACCESS_SEQUENTIAL) {

package/src/pipeline.h

@@ -67,6 +67,7 @@ struct PipelineBaton {
   int width;
   int height;
   int channels;
+  VipsKernel kernel;
   sharp::Canvas canvas;
   int position;
   std::vector<double> resizeBackground;
@@ -75,7 +76,6 @@ struct PipelineBaton {
   int cropOffsetTop;
   bool premultiplied;
   bool tileCentre;
-  std::string kernel;
   bool fastShrinkOnLoad;
   double tintA;
   double tintB;
@@ -97,11 +97,12 @@ struct PipelineBaton {
   double sharpenY3;
   int threshold;
   bool thresholdGrayscale;
+  std::vector<double> trimBackground;
   double trimThreshold;
   int trimOffsetLeft;
   int trimOffsetTop;
-  double linearA;
-  double linearB;
+  std::vector<double> linearA;
+  std::vector<double> linearB;
   double gamma;
   double gammaOut;
   bool greyscale;
@@ -157,9 +158,12 @@ struct PipelineBaton {
   bool webpLossless;
   bool webpSmartSubsample;
   int webpEffort;
+  bool webpMinSize;
+  bool webpMixed;
   int gifBitdepth;
   int gifEffort;
   double gifDither;
+  bool gifReoptimise;
   int tiffQuality;
   VipsForeignTiffCompression tiffCompression;
   VipsForeignTiffPredictor tiffPredictor;
@@ -209,6 +213,7 @@ struct PipelineBaton {
   int tileSkipBlanks;
   VipsForeignDzDepth tileDepth;
   std::string tileId;
+  std::string tileBasename;
   std::unique_ptr<double[]> recombMatrix;
 
   PipelineBaton():
@@ -217,6 +222,7 @@ struct PipelineBaton {
     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 },
@@ -244,11 +250,12 @@ struct PipelineBaton {
     sharpenY3(20.0),
     threshold(0),
     thresholdGrayscale(true),
+    trimBackground{},
     trimThreshold(0.0),
     trimOffsetLeft(0),
     trimOffsetTop(0),
-    linearA(1.0),
-    linearB(0.0),
+    linearA{},
+    linearB{},
     gamma(0.0),
     greyscale(false),
     normalise(false),
@@ -302,6 +309,12 @@ struct PipelineBaton {
     webpLossless(false),
     webpSmartSubsample(false),
     webpEffort(4),
+    webpMinSize(false),
+    webpMixed(false),
+    gifBitdepth(8),
+    gifEffort(7),
+    gifDither(1.0),
+    gifReoptimise(false),
     tiffQuality(80),
     tiffCompression(VIPS_FOREIGN_TIFF_COMPRESSION_JPEG),
     tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),