sharp 0.31.2 → 0.32.0

package/src/operations.cc

@@ -1,23 +1,11 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
 
 #include <algorithm>
 #include <functional>
 #include <memory>
 #include <tuple>
 #include <vector>
-
 #include <vips/vips8>
 
 #include "common.h"
@@ -57,7 +45,7 @@ namespace sharp {
   /*
    * Stretch luminance to cover full dynamic range.
    */
-  VImage Normalise(VImage image) {
+  VImage Normalise(VImage image, int const lower, int const upper) {
     // Get original colourspace
     VipsInterpretation typeBeforeNormalize = image.interpretation();
     if (typeBeforeNormalize == VIPS_INTERPRETATION_RGB) {
@@ -67,9 +55,11 @@ namespace sharp {
     VImage lab = image.colourspace(VIPS_INTERPRETATION_LAB);
     // Extract luminance
     VImage luminance = lab[0];
+
     // Find luminance range
-    int const min = luminance.percent(1);
-    int const max = luminance.percent(99);
+    int const min = lower == 0 ? luminance.min() : luminance.percent(lower);
+    int const max = upper == 100 ? luminance.max() : luminance.percent(upper);
+
     if (std::abs(max - min) > 1) {
       // Extract chroma
       VImage chroma = lab.extract_band(1, VImage::option()->set("n", 2));
@@ -345,9 +335,9 @@ namespace sharp {
     if (HasAlpha(image) && a.size() != bands && (a.size() == 1 || a.size() == bands - 1 || bands - 1 == 1)) {
       // Separate alpha channel
       VImage alpha = image[bands - 1];
-      return RemoveAlpha(image).linear(a, b).bandjoin(alpha);
+      return RemoveAlpha(image).linear(a, b, VImage::option()->set("uchar", TRUE)).bandjoin(alpha);
     } else {
-      return image.linear(a, b);
+      return image.linear(a, b, VImage::option()->set("uchar", TRUE));
     }
   }
 
@@ -395,11 +385,11 @@ namespace sharp {
    * Split into frames, embed each frame, reassemble, and update pageHeight.
    */
   VImage EmbedMultiPage(VImage image, int left, int top, int width, int height,
-                        std::vector<double> background, int nPages, int *pageHeight) {
+                        VipsExtend extendWith, std::vector<double> background, int nPages, int *pageHeight) {
     if (top == 0 && height == *pageHeight) {
       // Fast path; no need to adjust the height of the multi-page image
       return image.embed(left, 0, width, image.height(), VImage::option()
-        ->set("extend", VIPS_EXTEND_BACKGROUND)
+        ->set("extend", extendWith)
         ->set("background", background));
     } else if (left == 0 && width == image.width()) {
       // Fast path; no need to adjust the width of the multi-page image
@@ -411,7 +401,7 @@ namespace sharp {
 
       // Do the embed on the wide image
       image = image.embed(0, top, image.width(), height, VImage::option()
-        ->set("extend", VIPS_EXTEND_BACKGROUND)
+        ->set("extend", extendWith)
         ->set("background", background));
 
       // Split the wide image into frames
@@ -441,7 +431,7 @@ namespace sharp {
       // Embed each frame in the target size
       for (int i = 0; i < nPages; i++) {
         pages[i] = pages[i].embed(left, top, width, height, VImage::option()
-          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("extend", extendWith)
           ->set("background", background));
       }
 

package/src/operations.h

@@ -1,16 +1,5 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
 
 #ifndef SRC_OPERATIONS_H_
 #define SRC_OPERATIONS_H_
@@ -33,7 +22,7 @@ namespace sharp {
   /*
    * Stretch luminance to cover full dynamic range.
    */
-  VImage Normalise(VImage image);
+  VImage Normalise(VImage image, int const lower, int const upper);
 
   /*
    * Contrast limiting adapative histogram equalization (CLAHE)
@@ -124,7 +113,7 @@ namespace sharp {
    * Split into frames, embed each frame, reassemble, and update pageHeight.
    */
   VImage EmbedMultiPage(VImage image, int left, int top, int width, int height,
-                        std::vector<double> background, int nPages, int *pageHeight);
+                        VipsExtend extendWith, std::vector<double> background, int nPages, int *pageHeight);
 
 }  // namespace sharp
 

package/src/pipeline.cc

@@ -1,16 +1,5 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// Copyright 2013 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
 
 #include <algorithm>
 #include <cmath>
@@ -85,6 +74,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       VipsAngle autoRotation = VIPS_ANGLE_D0;
       bool autoFlip = FALSE;
       bool autoFlop = FALSE;
+
       if (baton->useExifOrientation) {
         // Rotate and flip image according to Exif orientation
         std::tie(autoRotation, autoFlip, autoFlop) = CalculateExifRotationAndFlip(sharp::ExifOrientation(image));
@@ -205,7 +195,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (jpegShrinkOnLoad > 1 && static_cast<int>(shrink) == jpegShrinkOnLoad) {
             jpegShrinkOnLoad /= 2;
           }
-        } else if (inputImageType == sharp::ImageType::WEBP && shrink > 1.0) {
+        } else if (inputImageType == sharp::ImageType::WEBP && baton->fastShrinkOnLoad && shrink > 1.0) {
           // Avoid upscaling via webp
           scale = 1.0 / shrink;
         } else if (inputImageType == sharp::ImageType::SVG ||
@@ -320,7 +310,8 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (
         sharp::HasProfile(image) &&
         image.interpretation() != VIPS_INTERPRETATION_LABS &&
-        image.interpretation() != VIPS_INTERPRETATION_GREY16
+        image.interpretation() != VIPS_INTERPRETATION_GREY16 &&
+        !baton->input->ignoreIcc
       ) {
         // Convert to sRGB/P3 using embedded profile
         try {
@@ -329,7 +320,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("depth", image.interpretation() == VIPS_INTERPRETATION_RGB16 ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
         } catch(...) {
-          // Ignore failure of embedded profile
+          sharp::VipsWarningCallback(nullptr, G_LOG_LEVEL_WARNING, "Invalid embedded profile", nullptr);
         }
       } else if (image.interpretation() == VIPS_INTERPRETATION_CMYK) {
         image = image.icc_transform(processingProfile, VImage::option()
@@ -367,11 +358,12 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::EnsureAlpha(image, 1);
       }
 
+      VipsBandFormat premultiplyFormat = image.format();
       bool const shouldPremultiplyAlpha = sharp::HasAlpha(image) &&
         (shouldResize || shouldBlur || shouldConv || shouldSharpen);
 
       if (shouldPremultiplyAlpha) {
-        image = image.premultiply();
+        image = image.premultiply().cast(premultiplyFormat);
       }
 
       // Resize
@@ -399,7 +391,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Join additional color channels to the image
-      if (baton->joinChannelIn.size() > 0) {
+      if (!baton->joinChannelIn.empty()) {
         VImage joinImage;
         sharp::ImageType joinImageType = sharp::ImageType::UNKNOWN;
 
@@ -409,6 +401,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = image.bandjoin(joinImage);
         }
         image = image.copy(VImage::option()->set("interpretation", baton->colourspace));
+        image = sharp::RemoveGifPalette(image);
       }
 
       inputWidth = image.width();
@@ -438,7 +431,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
           image = nPages > 1
             ? sharp::EmbedMultiPage(image,
-                left, top, width, height, background, nPages, &targetPageHeight)
+                left, top, width, height, VIPS_EXTEND_BACKGROUND, background, nPages, &targetPageHeight)
             : image.embed(left, top, width, height, VImage::option()
               ->set("extend", VIPS_EXTEND_BACKGROUND)
               ->set("background", background));
@@ -455,6 +448,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             // Gravity-based crop
             int left;
             int top;
+
             std::tie(left, top) = sharp::CalculateCrop(
               inputWidth, inputHeight, baton->width, baton->height, baton->position);
             int width = std::min(inputWidth, baton->width);
@@ -465,16 +459,25 @@ class PipelineWorker : public Napi::AsyncWorker {
                   left, top, width, height, nPages, &targetPageHeight)
               : image.extract_area(left, top, width, height);
           } else {
+            int attention_x;
+            int attention_y;
+
             // Attention-based or Entropy-based crop
             MultiPageUnsupported(nPages, "Resize strategy");
             image = image.tilecache(VImage::option()
               ->set("access", VIPS_ACCESS_RANDOM)
               ->set("threaded", TRUE));
+
             image = image.smartcrop(baton->width, baton->height, VImage::option()
-              ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION));
+              ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION)
+              ->set("attention_x", &attention_x)
+              ->set("attention_y", &attention_y));
             baton->hasCropOffset = true;
             baton->cropOffsetLeft = static_cast<int>(image.xoffset());
             baton->cropOffsetTop = static_cast<int>(image.yoffset());
+            baton->hasAttentionCenter = true;
+            baton->attentionX = static_cast<int>(attention_x * jpegShrinkOnLoad / scale);
+            baton->attentionY = static_cast<int>(attention_y * jpegShrinkOnLoad / scale);
           }
         }
       }
@@ -503,7 +506,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Affine transform
-      if (baton->affineMatrix.size() > 0) {
+      if (!baton->affineMatrix.empty()) {
         MultiPageUnsupported(nPages, "Affine");
         std::vector<double> background;
         std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground, shouldPremultiplyAlpha);
@@ -519,18 +522,29 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Extend edges
       if (baton->extendTop > 0 || baton->extendBottom > 0 || baton->extendLeft > 0 || baton->extendRight > 0) {
-        std::vector<double> background;
-        std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground, shouldPremultiplyAlpha);
-
         // Embed
         baton->width = image.width() + baton->extendLeft + baton->extendRight;
         baton->height = (nPages > 1 ? targetPageHeight : image.height()) + baton->extendTop + baton->extendBottom;
 
-        image = nPages > 1
-          ? sharp::EmbedMultiPage(image,
-              baton->extendLeft, baton->extendTop, baton->width, baton->height, background, nPages, &targetPageHeight)
-          : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
-              VImage::option()->set("extend", VIPS_EXTEND_BACKGROUND)->set("background", background));
+        if (baton->extendWith == VIPS_EXTEND_BACKGROUND) {
+          std::vector<double> background;
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground, shouldPremultiplyAlpha);
+
+          image = nPages > 1
+            ? sharp::EmbedMultiPage(image,
+                baton->extendLeft, baton->extendTop, baton->width, baton->height,
+                baton->extendWith, background, nPages, &targetPageHeight)
+            : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
+                VImage::option()->set("extend", baton->extendWith)->set("background", background));
+        } else {
+          std::vector<double> ignoredBackground(1);
+          image = nPages > 1
+            ? sharp::EmbedMultiPage(image,
+                baton->extendLeft, baton->extendTop, baton->width, baton->height,
+                baton->extendWith, ignoredBackground, nPages, &targetPageHeight)
+            : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
+                VImage::option()->set("extend", baton->extendWith));
+        }
       }
       // Median - must happen before blurring, due to the utility of blurring after thresholding
       if (baton->medianSize > 0) {
@@ -572,13 +586,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // 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);
-        }
+        image = image.unpremultiply().cast(premultiplyFormat);
       }
       baton->premultiplied = shouldPremultiplyAlpha;
 
@@ -660,6 +668,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           ys.push_back(top);
         }
         image = VImage::composite(images, modes, VImage::option()->set("x", xs)->set("y", ys));
+        image = sharp::RemoveGifPalette(image);
       }
 
       // Gamma decoding (brighten)
@@ -674,7 +683,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Apply normalisation - stretch luminance to cover full dynamic range
       if (baton->normalise) {
-        image = sharp::Normalise(image);
+        image = sharp::Normalise(image,  baton->normaliseLower, baton->normaliseUpper);
       }
 
       // Apply contrast limiting adaptive histogram equalization (CLAHE)
@@ -689,6 +698,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         std::tie(booleanImage, booleanImageType) = sharp::OpenInput(baton->boolean);
         booleanImage = sharp::EnsureColourspace(booleanImage, baton->colourspaceInput);
         image = sharp::Boolean(image, booleanImage, baton->booleanOp);
+        image = sharp::RemoveGifPalette(image);
       }
 
       // Apply per-channel Bandbool bitwise operations after all other operations
@@ -701,24 +711,6 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = sharp::Tint(image, baton->tintA, baton->tintB);
       }
 
-      // Extract an image channel (aka vips band)
-      if (baton->extractChannel > -1) {
-        if (baton->extractChannel >= image.bands()) {
-          if (baton->extractChannel == 3 && sharp::HasAlpha(image)) {
-            baton->extractChannel = image.bands() - 1;
-          } else {
-            (baton->err).append("Cannot extract channel from image. Too few channels in image.");
-            return Error();
-          }
-        }
-        VipsInterpretation const interpretation = sharp::Is16Bit(image.interpretation())
-          ? VIPS_INTERPRETATION_GREY16
-          : VIPS_INTERPRETATION_B_W;
-        image = image
-          .extract_band(baton->extractChannel)
-          .copy(VImage::option()->set("interpretation", interpretation));
-      }
-
       // Remove alpha channel, if any
       if (baton->removeAlpha) {
         image = sharp::RemoveAlpha(image);
@@ -744,6 +736,26 @@ class PipelineWorker : public Napi::AsyncWorker {
         }
       }
 
+      // Extract channel
+      if (baton->extractChannel > -1) {
+        if (baton->extractChannel >= image.bands()) {
+          if (baton->extractChannel == 3 && sharp::HasAlpha(image)) {
+            baton->extractChannel = image.bands() - 1;
+          } else {
+            (baton->err)
+              .append("Cannot extract channel ").append(std::to_string(baton->extractChannel))
+              .append(" from image with channels 0-").append(std::to_string(image.bands() - 1));
+            return Error();
+          }
+        }
+        VipsInterpretation colourspace = sharp::Is16Bit(image.interpretation())
+          ? VIPS_INTERPRETATION_GREY16
+          : VIPS_INTERPRETATION_B_W;
+        image = image
+          .extract_band(baton->extractChannel)
+          .copy(VImage::option()->set("interpretation", colourspace));
+      }
+
       // Apply output ICC profile
       if (!baton->withMetadataIcc.empty()) {
         image = image.icc_transform(
@@ -868,7 +880,10 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("strip", !baton->withMetadata)
             ->set("bitdepth", baton->gifBitdepth)
             ->set("effort", baton->gifEffort)
-            ->set("reoptimise", baton->gifReoptimise)
+            ->set("reuse", baton->gifReuse)
+            ->set("interlace", baton->gifProgressive)
+            ->set("interframe_maxerror", baton->gifInterFrameMaxError)
+            ->set("interpalette_maxerror", baton->gifInterPaletteMaxError)
             ->set("dither", baton->gifDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -935,6 +950,21 @@ class PipelineWorker : public Napi::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "dz";
+        } else if (baton->formatOut == "jxl" ||
+          (baton->formatOut == "input" && inputImageType == sharp::ImageType::JXL)) {
+          // Write JXL to buffer
+          image = sharp::RemoveAnimationProperties(image);
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.jxlsave_buffer(VImage::option()
+            ->set("strip", !baton->withMetadata)
+            ->set("distance", baton->jxlDistance)
+            ->set("tier", baton->jxlDecodingTier)
+            ->set("effort", baton->jxlEffort)
+            ->set("lossless", baton->jxlLossless)));
+          baton->bufferOut = static_cast<char*>(area->data);
+          baton->bufferOutLength = area->length;
+          area->free_fn = nullptr;
+          vips_area_unref(area);
+          baton->formatOut = "jxl";
         } else if (baton->formatOut == "raw" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::RAW)) {
           // Write raw, uncompressed image data to buffer
@@ -973,6 +1003,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         bool const isTiff = sharp::IsTiff(baton->fileOut);
         bool const isJp2 = sharp::IsJp2(baton->fileOut);
         bool const isHeif = sharp::IsHeif(baton->fileOut);
+        bool const isJxl = sharp::IsJxl(baton->fileOut);
         bool const isDz = sharp::IsDz(baton->fileOut);
         bool const isDzZip = sharp::IsDzZip(baton->fileOut);
         bool const isV = sharp::IsV(baton->fileOut);
@@ -1048,7 +1079,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("strip", !baton->withMetadata)
             ->set("bitdepth", baton->gifBitdepth)
             ->set("effort", baton->gifEffort)
-            ->set("reoptimise", baton->gifReoptimise)
+            ->set("reuse", baton->gifReuse)
+            ->set("interlace", baton->gifProgressive)
             ->set("dither", baton->gifDither));
           baton->formatOut = "gif";
         } else if (baton->formatOut == "tiff" || (mightMatchInput && isTiff) ||
@@ -1090,6 +1122,17 @@ class PipelineWorker : public Napi::AsyncWorker {
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("lossless", baton->heifLossless));
           baton->formatOut = "heif";
+        } else if (baton->formatOut == "jxl" || (mightMatchInput && isJxl) ||
+          (willMatchInput && inputImageType == sharp::ImageType::JXL)) {
+          // Write JXL to file
+          image = sharp::RemoveAnimationProperties(image);
+          image.jxlsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+            ->set("strip", !baton->withMetadata)
+            ->set("distance", baton->jxlDistance)
+            ->set("tier", baton->jxlDecodingTier)
+            ->set("effort", baton->jxlEffort)
+            ->set("lossless", baton->jxlLossless));
+          baton->formatOut = "jxl";
         } else if (baton->formatOut == "dz" || isDz || isDzZip) {
           // Write DZ to file
           if (isDzZip) {
@@ -1133,7 +1176,7 @@ class PipelineWorker : public Napi::AsyncWorker {
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      debuglog.Call({ Napi::String::New(env, warning) });
+      debuglog.MakeCallback(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
@@ -1162,6 +1205,10 @@ class PipelineWorker : public Napi::AsyncWorker {
         info.Set("cropOffsetLeft", static_cast<int32_t>(baton->cropOffsetLeft));
         info.Set("cropOffsetTop", static_cast<int32_t>(baton->cropOffsetTop));
       }
+      if (baton->hasAttentionCenter) {
+        info.Set("attentionX", static_cast<int32_t>(baton->attentionX));
+        info.Set("attentionY", static_cast<int32_t>(baton->attentionY));
+      }
       if (baton->trimThreshold > 0.0) {
         info.Set("trimOffsetLeft", static_cast<int32_t>(baton->trimOffsetLeft));
         info.Set("trimOffsetTop", static_cast<int32_t>(baton->trimOffsetTop));
@@ -1175,8 +1222,8 @@ class PipelineWorker : public Napi::AsyncWorker {
         // Add buffer size to info
         info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));
         // Pass ownership of output data to Buffer instance
-        Napi::Buffer<char> data = Napi::Buffer<char>::New(env, static_cast<char*>(baton->bufferOut),
-          baton->bufferOutLength, sharp::FreeCallback);
+        Napi::Buffer<char> data = sharp::NewOrCopyBuffer(env, static_cast<char*>(baton->bufferOut),
+          baton->bufferOutLength);
         Callback().MakeCallback(Receiver().Value(), { env.Null(), data, info });
       } else {
         // Add file size to info
@@ -1187,7 +1234,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
       }
     } else {
-      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
+      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
     }
 
     // Delete baton
@@ -1205,7 +1252,7 @@ class PipelineWorker : public Napi::AsyncWorker {
     // Decrement processing task counter
     g_atomic_int_dec_and_test(&sharp::counterProcess);
     Napi::Number queueLength = Napi::Number::New(env, static_cast<double>(sharp::counterQueue));
-    queueListener.Call(Receiver().Value(), { queueLength });
+    queueListener.MakeCallback(Receiver().Value(), { queueLength });
   }
 
  private:
@@ -1351,7 +1398,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 Napi::Value pipeline(const Napi::CallbackInfo& info) {
   // V8 objects are converted to non-V8 types held in the baton struct
   PipelineBaton *baton = new PipelineBaton;
-  Napi::Object options = info[0].As<Napi::Object>();
+  Napi::Object options = info[size_t(0)].As<Napi::Object>();
 
   // Input
   baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
@@ -1437,6 +1484,8 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->linearB = sharp::AttrAsVectorOfDouble(options, "linearB");
   baton->greyscale = sharp::AttrAsBool(options, "greyscale");
   baton->normalise = sharp::AttrAsBool(options, "normalise");
+  baton->normaliseLower = sharp::AttrAsUint32(options, "normaliseLower");
+  baton->normaliseUpper = sharp::AttrAsUint32(options, "normaliseUpper");
   baton->tintA = sharp::AttrAsDouble(options, "tintA");
   baton->tintB = sharp::AttrAsDouble(options, "tintB");
   baton->claheWidth = sharp::AttrAsUint32(options, "claheWidth");
@@ -1454,6 +1503,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->extendLeft = sharp::AttrAsInt32(options, "extendLeft");
   baton->extendRight = sharp::AttrAsInt32(options, "extendRight");
   baton->extendBackground = sharp::AttrAsVectorOfDouble(options, "extendBackground");
+  baton->extendWith = sharp::AttrAsEnum<VipsExtend>(options, "extendWith", VIPS_TYPE_EXTEND);
   baton->extractChannel = sharp::AttrAsInt32(options, "extractChannel");
   baton->affineMatrix = sharp::AttrAsVectorOfDouble(options, "affineMatrix");
   baton->affineBackground = sharp::AttrAsVectorOfDouble(options, "affineBackground");
@@ -1549,7 +1599,10 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   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->gifInterFrameMaxError = sharp::AttrAsDouble(options, "gifInterFrameMaxError");
+  baton->gifInterPaletteMaxError = sharp::AttrAsDouble(options, "gifInterPaletteMaxError");
+  baton->gifReuse = sharp::AttrAsBool(options, "gifReuse");
+  baton->gifProgressive = sharp::AttrAsBool(options, "gifProgressive");
   baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");
   baton->tiffPyramid = sharp::AttrAsBool(options, "tiffPyramid");
   baton->tiffBitdepth = sharp::AttrAsUint32(options, "tiffBitdepth");
@@ -1573,6 +1626,10 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     options, "heifCompression", VIPS_TYPE_FOREIGN_HEIF_COMPRESSION);
   baton->heifEffort = sharp::AttrAsUint32(options, "heifEffort");
   baton->heifChromaSubsampling = sharp::AttrAsStr(options, "heifChromaSubsampling");
+  baton->jxlDistance = sharp::AttrAsDouble(options, "jxlDistance");
+  baton->jxlDecodingTier = sharp::AttrAsUint32(options, "jxlDecodingTier");
+  baton->jxlEffort = sharp::AttrAsUint32(options, "jxlEffort");
+  baton->jxlLossless = sharp::AttrAsBool(options, "jxlLossless");
   baton->rawDepth = sharp::AttrAsEnum<VipsBandFormat>(options, "rawDepth", VIPS_TYPE_BAND_FORMAT);
   // Animated output properties
   if (sharp::HasAttr(options, "loop")) {
@@ -1601,9 +1658,12 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
       baton->trimThreshold > 0.0 ||
       baton->normalise ||
       baton->position == 16 || baton->position == 17 ||
-      baton->angle % 360 != 0 ||
-      fmod(baton->rotationAngle, 360.0) != 0.0 ||
-      baton->useExifOrientation
+      baton->angle != 0 ||
+      baton->rotationAngle != 0.0 ||
+      baton->tileAngle != 0 ||
+      baton->useExifOrientation ||
+      baton->claheWidth != 0 ||
+      !baton->affineMatrix.empty()
     ) {
       baton->input->access = VIPS_ACCESS_RANDOM;
     }
@@ -1616,7 +1676,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   Napi::Function queueListener = options.Get("queueListener").As<Napi::Function>();
 
   // Join queue for worker thread
-  Napi::Function callback = info[1].As<Napi::Function>();
+  Napi::Function callback = info[size_t(1)].As<Napi::Function>();
   PipelineWorker *worker = new PipelineWorker(callback, baton, debuglog, queueListener);
   worker->Receiver().Set("options", options);
   worker->Queue();
@@ -1624,7 +1684,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   // Increment queued task counter
   g_atomic_int_inc(&sharp::counterQueue);
   Napi::Number queueLength = Napi::Number::New(info.Env(), static_cast<double>(sharp::counterQueue));
-  queueListener.Call(info.This(), { queueLength });
+  queueListener.MakeCallback(info.This(), { queueLength });
 
   return info.Env().Undefined();
 }