sharp 0.29.0 → 0.30.0

package/src/pipeline.cc

@@ -69,15 +69,24 @@ class PipelineWorker : public Napi::AsyncWorker {
       std::tie(image, inputImageType) = sharp::OpenInput(baton->input);
       image = sharp::EnsureColourspace(image, baton->colourspaceInput);
 
+      int nPages = baton->input->pages;
+      if (nPages == -1) {
+        // Resolve the number of pages if we need to render until the end of the document
+        nPages = image.get_typeof(VIPS_META_N_PAGES) != 0
+          ? image.get_int(VIPS_META_N_PAGES) - baton->input->page
+          : 1;
+      }
+
+      // Get pre-resize page height
+      int pageHeight = sharp::GetPageHeight(image);
+
       // Calculate angle of rotation
       VipsAngle rotation;
+      bool flip = FALSE;
+      bool flop = FALSE;
       if (baton->useExifOrientation) {
         // Rotate and flip image according to Exif orientation
-        bool flip;
-        bool flop;
         std::tie(rotation, flip, flop) = CalculateExifRotationAndFlip(sharp::ExifOrientation(image));
-        baton->flip = baton->flip || flip;
-        baton->flop = baton->flop || flop;
       } else {
         rotation = CalculateAngleRotation(baton->angle);
       }
@@ -86,17 +95,27 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (baton->rotateBeforePreExtract) {
         if (rotation != VIPS_ANGLE_D0) {
           image = image.rot(rotation);
+          if (flip) {
+            image = image.flip(VIPS_DIRECTION_VERTICAL);
+            flip = FALSE;
+          }
+          if (flop) {
+            image = image.flip(VIPS_DIRECTION_HORIZONTAL);
+            flop = FALSE;
+          }
           image = sharp::RemoveExifOrientation(image);
         }
         if (baton->rotationAngle != 0.0) {
+          MultiPageUnsupported(nPages, "Rotate");
           std::vector<double> background;
-          std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground);
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, FALSE);
           image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
         }
       }
 
       // Trim
       if (baton->trimThreshold > 0.0) {
+        MultiPageUnsupported(nPages, "Trim");
         image = sharp::Trim(image, baton->trimThreshold);
         baton->trimOffsetLeft = image.xoffset();
         baton->trimOffsetTop = image.yoffset();
@@ -104,201 +123,194 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Pre extraction
       if (baton->topOffsetPre != -1) {
-        image = image.extract_area(baton->leftOffsetPre, baton->topOffsetPre, baton->widthPre, baton->heightPre);
+        image = nPages > 1
+          ? sharp::CropMultiPage(image,
+              baton->leftOffsetPre, baton->topOffsetPre, baton->widthPre, baton->heightPre, nPages, &pageHeight)
+          : image.extract_area(baton->leftOffsetPre, baton->topOffsetPre, baton->widthPre, baton->heightPre);
       }
 
       // Get pre-resize image width and height
       int inputWidth = image.width();
       int inputHeight = image.height();
-      if (!baton->rotateBeforePreExtract &&
-        (rotation == VIPS_ANGLE_D90 || rotation == VIPS_ANGLE_D270)) {
-        // Swap input output width and height when rotating by 90 or 270 degrees
-        std::swap(inputWidth, inputHeight);
+
+      // Is there just one page? Shrink to inputHeight instead
+      if (nPages == 1) {
+        pageHeight = inputHeight;
       }
 
-      // If withoutEnlargement is specified,
-      // Override target width and height if exceeds respective value from input file
-      if (baton->withoutEnlargement) {
-        if (baton->width > inputWidth) {
-          baton->width = inputWidth;
-        }
-        if (baton->height > inputHeight) {
-          baton->height = inputHeight;
-        }
+      // If withoutReduction is specified,
+      // Override target width and height if less than respective value from input file
+       if (baton->withoutReduction) {
+          if (baton->width < inputWidth) {
+            baton->width = inputWidth;
+          }
+          if (baton->height < inputHeight) {
+            baton->height = inputHeight;
+          }
       }
 
       // Scaling calculations
-      double xfactor = 1.0;
-      double yfactor = 1.0;
+      double hshrink;
+      double vshrink;
       int targetResizeWidth = baton->width;
       int targetResizeHeight = baton->height;
-      if (baton->width > 0 && baton->height > 0) {
-        // Fixed width and height
-        xfactor = static_cast<double>(inputWidth) / static_cast<double>(baton->width);
-        yfactor = static_cast<double>(inputHeight) / static_cast<double>(baton->height);
-        switch (baton->canvas) {
-          case Canvas::CROP:
-            if (xfactor < yfactor) {
-              targetResizeHeight = static_cast<int>(round(static_cast<double>(inputHeight) / xfactor));
-              yfactor = xfactor;
-            } else {
-              targetResizeWidth = static_cast<int>(round(static_cast<double>(inputWidth) / yfactor));
-              xfactor = yfactor;
-            }
-            break;
-          case Canvas::EMBED:
-            if (xfactor > yfactor) {
-              targetResizeHeight = static_cast<int>(round(static_cast<double>(inputHeight) / xfactor));
-              yfactor = xfactor;
-            } else {
-              targetResizeWidth = static_cast<int>(round(static_cast<double>(inputWidth) / yfactor));
-              xfactor = yfactor;
-            }
-            break;
-          case Canvas::MAX:
-            if (xfactor > yfactor) {
-              targetResizeHeight = baton->height = static_cast<int>(round(static_cast<double>(inputHeight) / xfactor));
-              yfactor = xfactor;
-            } else {
-              targetResizeWidth = baton->width = static_cast<int>(round(static_cast<double>(inputWidth) / yfactor));
-              xfactor = yfactor;
-            }
-            break;
-          case Canvas::MIN:
-            if (xfactor < yfactor) {
-              targetResizeHeight = baton->height = static_cast<int>(round(static_cast<double>(inputHeight) / xfactor));
-              yfactor = xfactor;
-            } else {
-              targetResizeWidth = baton->width = static_cast<int>(round(static_cast<double>(inputWidth) / yfactor));
-              xfactor = yfactor;
-            }
-            break;
-          case Canvas::IGNORE_ASPECT:
-            if (!baton->rotateBeforePreExtract &&
-              (rotation == VIPS_ANGLE_D90 || rotation == VIPS_ANGLE_D270)) {
-              std::swap(xfactor, yfactor);
-            }
-            break;
-        }
-      } else if (baton->width > 0) {
-        // Fixed width
-        xfactor = static_cast<double>(inputWidth) / static_cast<double>(baton->width);
-        if (baton->canvas == Canvas::IGNORE_ASPECT) {
-          targetResizeHeight = baton->height = inputHeight;
-        } else {
-          // Auto height
-          yfactor = xfactor;
-          targetResizeHeight = baton->height = static_cast<int>(round(static_cast<double>(inputHeight) / yfactor));
-        }
-      } else if (baton->height > 0) {
-        // Fixed height
-        yfactor = static_cast<double>(inputHeight) / static_cast<double>(baton->height);
-        if (baton->canvas == Canvas::IGNORE_ASPECT) {
-          targetResizeWidth = baton->width = inputWidth;
-        } else {
-          // Auto width
-          xfactor = yfactor;
-          targetResizeWidth = baton->width = static_cast<int>(round(static_cast<double>(inputWidth) / xfactor));
-        }
-      } else {
-        // Identity transform
-        baton->width = inputWidth;
-        baton->height = inputHeight;
-      }
 
-      // Calculate integral box shrink
-      int xshrink = std::max(1, static_cast<int>(floor(xfactor)));
-      int yshrink = std::max(1, static_cast<int>(floor(yfactor)));
+      // Swap input output width and height when rotating by 90 or 270 degrees
+      bool swap = !baton->rotateBeforePreExtract && (rotation == VIPS_ANGLE_D90 || rotation == VIPS_ANGLE_D270);
 
-      // Calculate residual float affine transformation
-      double xresidual = static_cast<double>(xshrink) / xfactor;
-      double yresidual = static_cast<double>(yshrink) / yfactor;
+      // Shrink to pageHeight, so we work for multi-page images
+      std::tie(hshrink, vshrink) = sharp::ResolveShrink(
+        inputWidth, pageHeight, targetResizeWidth, targetResizeHeight,
+        baton->canvas, swap, baton->withoutEnlargement);
 
-      // If integral x and y shrink are equal, try to use shrink-on-load for JPEG and WebP,
-      // but not when applying gamma correction, pre-resize extract, trim or input colourspace
-      int shrink_on_load = 1;
+      // The jpeg preload shrink.
+      int jpegShrinkOnLoad = 1;
 
-      int shrink_on_load_factor = 1;
-      // Leave at least a factor of two for the final resize step, when fastShrinkOnLoad: false
-      // for more consistent results and avoid occasional small image shifting
-      if (!baton->fastShrinkOnLoad) {
-        shrink_on_load_factor = 2;
-      }
-      if (
-        xshrink == yshrink && xshrink >= 2 * shrink_on_load_factor &&
-        (inputImageType == sharp::ImageType::JPEG || inputImageType == sharp::ImageType::WEBP) &&
+      // WebP, PDF, SVG scale
+      double scale = 1.0;
+
+      // Try to reload input using shrink-on-load for JPEG, WebP, SVG and PDF, when:
+      //  - the width or height parameters are specified;
+      //  - gamma correction doesn't need to be applied;
+      //  - trimming or pre-resize extract isn't required;
+      //  - input colourspace is not specified;
+      bool const shouldPreShrink = (targetResizeWidth > 0 || targetResizeHeight > 0) &&
         baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0 &&
-        baton->colourspaceInput == VIPS_INTERPRETATION_LAST &&
-        image.width() > 3 && image.height() > 3 && baton->input->pages == 1
-      ) {
-        if (xshrink >= 8 * shrink_on_load_factor) {
-          xfactor = xfactor / 8;
-          yfactor = yfactor / 8;
-          shrink_on_load = 8;
-        } else if (xshrink >= 4 * shrink_on_load_factor) {
-          xfactor = xfactor / 4;
-          yfactor = yfactor / 4;
-          shrink_on_load = 4;
-        } else if (xshrink >= 2 * shrink_on_load_factor) {
-          xfactor = xfactor / 2;
-          yfactor = yfactor / 2;
-          shrink_on_load = 2;
+        baton->colourspaceInput == VIPS_INTERPRETATION_LAST;
+
+      if (shouldPreShrink) {
+        // The common part of the shrink: the bit by which both axes must be shrunk
+        double shrink = std::min(hshrink, vshrink);
+
+        if (inputImageType == sharp::ImageType::JPEG) {
+          // Leave at least a factor of two for the final resize step, when fastShrinkOnLoad: false
+          // for more consistent results and avoid occasional small image shifting
+          int factor = baton->fastShrinkOnLoad ? 1 : 2;
+          if (shrink >= 8 * factor) {
+            jpegShrinkOnLoad = 8;
+          } else if (shrink >= 4 * factor) {
+            jpegShrinkOnLoad = 4;
+          } else if (shrink >= 2 * factor) {
+            jpegShrinkOnLoad = 2;
+          }
+        } else if (inputImageType == sharp::ImageType::WEBP ||
+                   inputImageType == sharp::ImageType::SVG ||
+                   inputImageType == sharp::ImageType::PDF) {
+          scale = 1.0 / shrink;
         }
       }
-      // Help ensure a final kernel-based reduction to prevent shrink aliasing
-      if (shrink_on_load > 1 && (xresidual == 1.0 || yresidual == 1.0)) {
-        shrink_on_load = shrink_on_load / 2;
-        xfactor = xfactor * 2;
-        yfactor = yfactor * 2;
-      }
-      if (shrink_on_load > 1) {
-        // Reload input using shrink-on-load
+
+      // Reload input using shrink-on-load, it'll be an integer shrink
+      // factor for jpegload*, a double scale factor for webpload*,
+      // pdfload* and svgload*
+      if (jpegShrinkOnLoad > 1) {
         vips::VOption *option = VImage::option()
           ->set("access", baton->input->access)
-          ->set("shrink", shrink_on_load)
+          ->set("shrink", jpegShrinkOnLoad)
           ->set("fail", baton->input->failOnError);
         if (baton->input->buffer != nullptr) {
+          // Reload JPEG buffer
           VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
-          if (inputImageType == sharp::ImageType::JPEG) {
-            // Reload JPEG buffer
-            image = VImage::jpegload_buffer(blob, option);
-          } else {
-            // Reload WebP buffer
-            image = VImage::webpload_buffer(blob, option);
-          }
+          image = VImage::jpegload_buffer(blob, option);
           vips_area_unref(reinterpret_cast<VipsArea*>(blob));
         } else {
-          if (inputImageType == sharp::ImageType::JPEG) {
-            // Reload JPEG file
-            image = VImage::jpegload(const_cast<char*>(baton->input->file.data()), option);
+          // Reload JPEG file
+          image = VImage::jpegload(const_cast<char*>(baton->input->file.data()), option);
+        }
+      } else if (scale != 1.0) {
+        vips::VOption *option = VImage::option()
+          ->set("access", baton->input->access)
+          ->set("scale", scale)
+          ->set("fail", baton->input->failOnError);
+        if (inputImageType == sharp::ImageType::WEBP) {
+          option->set("n", baton->input->pages);
+          option->set("page", baton->input->page);
+
+          if (baton->input->buffer != nullptr) {
+            // Reload WebP buffer
+            VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
+            image = VImage::webpload_buffer(blob, option);
+            vips_area_unref(reinterpret_cast<VipsArea*>(blob));
           } else {
             // Reload WebP file
             image = VImage::webpload(const_cast<char*>(baton->input->file.data()), option);
           }
+        } else if (inputImageType == sharp::ImageType::SVG) {
+          option->set("unlimited", baton->input->unlimited);
+          option->set("dpi", baton->input->density);
+
+          if (baton->input->buffer != nullptr) {
+            // Reload SVG buffer
+            VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
+            image = VImage::svgload_buffer(blob, option);
+            vips_area_unref(reinterpret_cast<VipsArea*>(blob));
+          } else {
+            // Reload SVG file
+            image = VImage::svgload(const_cast<char*>(baton->input->file.data()), option);
+          }
+
+          sharp::SetDensity(image, baton->input->density);
+        } else if (inputImageType == sharp::ImageType::PDF) {
+          option->set("n", baton->input->pages);
+          option->set("page", baton->input->page);
+          option->set("dpi", baton->input->density);
+
+          if (baton->input->buffer != nullptr) {
+            // Reload PDF buffer
+            VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
+            image = VImage::pdfload_buffer(blob, option);
+            vips_area_unref(reinterpret_cast<VipsArea*>(blob));
+          } else {
+            // Reload PDF file
+            image = VImage::pdfload(const_cast<char*>(baton->input->file.data()), option);
+          }
+
+          sharp::SetDensity(image, baton->input->density);
         }
-        // Recalculate integral shrink and double residual
-        int const shrunkOnLoadWidth = image.width();
-        int const shrunkOnLoadHeight = image.height();
-        if (!baton->rotateBeforePreExtract &&
-          (rotation == VIPS_ANGLE_D90 || rotation == VIPS_ANGLE_D270)) {
-          // Swap when rotating by 90 or 270 degrees
-          xfactor = static_cast<double>(shrunkOnLoadWidth) / static_cast<double>(targetResizeHeight);
-          yfactor = static_cast<double>(shrunkOnLoadHeight) / static_cast<double>(targetResizeWidth);
-        } else {
-          xfactor = static_cast<double>(shrunkOnLoadWidth) / static_cast<double>(targetResizeWidth);
-          yfactor = static_cast<double>(shrunkOnLoadHeight) / static_cast<double>(targetResizeHeight);
-        }
+      }
+
+      // Any pre-shrinking may already have been done
+      int thumbWidth = image.width();
+      int thumbHeight = image.height();
+
+      // After pre-shrink, but before the main shrink stage
+      // Reuse the initial pageHeight if we didn't pre-shrink
+      int preshrunkPageHeight = shouldPreShrink ? sharp::GetPageHeight(image) : pageHeight;
+
+      if (baton->fastShrinkOnLoad && jpegShrinkOnLoad > 1) {
+        // JPEG shrink-on-load rounds the output dimensions down, which
+        // may cause incorrect dimensions when fastShrinkOnLoad is enabled
+        // Just recalculate vshrink / hshrink on the main image instead of
+        // the pre-shrunk image when this is the case
+        hshrink = static_cast<double>(thumbWidth) / (static_cast<double>(inputWidth) / hshrink);
+        vshrink = static_cast<double>(preshrunkPageHeight) / (static_cast<double>(pageHeight) / vshrink);
+      } else {
+        // Shrink to preshrunkPageHeight, so we work for multi-page images
+        std::tie(hshrink, vshrink) = sharp::ResolveShrink(
+          thumbWidth, preshrunkPageHeight, targetResizeWidth, targetResizeHeight,
+          baton->canvas, swap, baton->withoutEnlargement);
+      }
+
+      int targetHeight = static_cast<int>(std::rint(static_cast<double>(preshrunkPageHeight) / vshrink));
+      int targetPageHeight = targetHeight;
+
+      // In toilet-roll mode, we must adjust vshrink so that we exactly hit
+      // preshrunkPageHeight or we'll have pixels straddling pixel boundaries
+      if (thumbHeight > preshrunkPageHeight) {
+        targetHeight *= nPages;
+        vshrink = static_cast<double>(thumbHeight) / targetHeight;
       }
 
       // Ensure we're using a device-independent colour space
+      char const *processingProfile = image.interpretation() == VIPS_INTERPRETATION_RGB16 ? "p3" : "srgb";
       if (
         sharp::HasProfile(image) &&
         image.interpretation() != VIPS_INTERPRETATION_LABS &&
         image.interpretation() != VIPS_INTERPRETATION_GREY16
       ) {
-        // Convert to sRGB using embedded profile
+        // Convert to sRGB/P3 using embedded profile
         try {
-          image = image.icc_transform("srgb", VImage::option()
+          image = image.icc_transform(processingProfile, VImage::option()
             ->set("embedded", TRUE)
             ->set("depth", image.interpretation() == VIPS_INTERPRETATION_RGB16 ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
@@ -306,7 +318,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           // Ignore failure of embedded profile
         }
       } else if (image.interpretation() == VIPS_INTERPRETATION_CMYK) {
-        image = image.icc_transform("srgb", VImage::option()
+        image = image.icc_transform(processingProfile, VImage::option()
           ->set("input_profile", "cmyk")
           ->set("intent", VIPS_INTENT_PERCEPTUAL));
       }
@@ -340,13 +352,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.colourspace(VIPS_INTERPRETATION_B_W);
       }
 
-      bool const shouldResize = xfactor != 1.0 || yfactor != 1.0;
+      bool const shouldResize = hshrink != 1.0 || vshrink != 1.0;
       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;
+      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)) {
@@ -373,35 +386,33 @@ class PipelineWorker : public Napi::AsyncWorker {
         ) {
           throw vips::VError("Unknown kernel");
         }
-        // Ensure shortest edge is at least 1 pixel
-        if (image.width() / xfactor < 0.5) {
-          xfactor = 2 * image.width();
-          baton->width = 1;
-        }
-        if (image.height() / yfactor < 0.5) {
-          yfactor = 2 * image.height();
-          baton->height = 1;
-        }
-        image = image.resize(1.0 / xfactor, VImage::option()
-          ->set("vscale", 1.0 / yfactor)
+        image = image.resize(1.0 / hshrink, VImage::option()
+          ->set("vscale", 1.0 / vshrink)
           ->set("kernel", kernel));
       }
 
       // Rotate post-extract 90-angle
-      if (!baton->rotateBeforePreExtract &&  rotation != VIPS_ANGLE_D0) {
-          image = image.rot(rotation);
-          image = sharp::RemoveExifOrientation(image);
+      if (!baton->rotateBeforePreExtract && rotation != VIPS_ANGLE_D0) {
+        image = image.rot(rotation);
+        if (flip) {
+          image = image.flip(VIPS_DIRECTION_VERTICAL);
+          flip = FALSE;
+        }
+        if (flop) {
+          image = image.flip(VIPS_DIRECTION_HORIZONTAL);
+          flop = FALSE;
+        }
+        image = sharp::RemoveExifOrientation(image);
       }
 
-
       // Flip (mirror about Y axis)
-      if (baton->flip) {
+      if (baton->flip || flip) {
         image = image.flip(VIPS_DIRECTION_VERTICAL);
         image = sharp::RemoveExifOrientation(image);
       }
 
       // Flop (mirror about X axis)
-      if (baton->flop) {
+      if (baton->flop || flop) {
         image = image.flip(VIPS_DIRECTION_HORIZONTAL);
         image = sharp::RemoveExifOrientation(image);
       }
@@ -419,52 +430,68 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.copy(VImage::option()->set("interpretation", baton->colourspace));
       }
 
+      inputWidth = image.width();
+      inputHeight = nPages > 1 ? targetPageHeight : image.height();
+
+      // Resolve dimensions
+      if (baton->width <= 0) {
+        baton->width = inputWidth;
+      }
+      if (baton->height <= 0) {
+        baton->height = inputHeight;
+      }
+
       // Crop/embed
-      if (image.width() != baton->width || image.height() != baton->height) {
-        if (baton->canvas == Canvas::EMBED) {
+      if (inputWidth != baton->width || inputHeight != baton->height) {
+        if (baton->canvas == sharp::Canvas::EMBED) {
           std::vector<double> background;
-          std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground);
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground, shouldPremultiplyAlpha);
 
           // Embed
 
-          // Calculate where to position the embeded image if gravity specified, else center.
+          // Calculate where to position the embedded image if gravity specified, else center.
           int left;
           int top;
 
-          left = static_cast<int>(round((baton->width - image.width()) / 2));
-          top = static_cast<int>(round((baton->height - image.height()) / 2));
+          left = static_cast<int>(round((baton->width - inputWidth) / 2));
+          top = static_cast<int>(round((baton->height - inputHeight) / 2));
 
-          int width = std::max(image.width(), baton->width);
-          int height = std::max(image.height(), baton->height);
+          int width = std::max(inputWidth, baton->width);
+          int height = std::max(inputHeight, baton->height);
           std::tie(left, top) = sharp::CalculateEmbedPosition(
-            image.width(), image.height(), baton->width, baton->height, baton->position);
-
-          image = image.embed(left, top, width, height, VImage::option()
-            ->set("extend", VIPS_EXTEND_BACKGROUND)
-            ->set("background", background));
+            inputWidth, inputHeight, baton->width, baton->height, baton->position);
+
+          image = nPages > 1
+            ? sharp::EmbedMultiPage(image,
+                left, top, width, height, background, nPages, &targetPageHeight)
+            : image.embed(left, top, width, height, VImage::option()
+              ->set("extend", VIPS_EXTEND_BACKGROUND)
+              ->set("background", background));
+        } else if (baton->canvas == sharp::Canvas::CROP) {
+          if (baton->width > inputWidth) {
+            baton->width = inputWidth;
+          }
+          if (baton->height > inputHeight) {
+            baton->height = inputHeight;
+          }
 
-        } else if (
-          baton->canvas != Canvas::IGNORE_ASPECT &&
-          (image.width() > baton->width || image.height() > baton->height)
-        ) {
-          // Crop/max/min
+          // Crop
           if (baton->position < 9) {
             // Gravity-based crop
             int left;
             int top;
             std::tie(left, top) = sharp::CalculateCrop(
-              image.width(), image.height(), baton->width, baton->height, baton->position);
-            int width = std::min(image.width(), baton->width);
-            int height = std::min(image.height(), baton->height);
-            image = image.extract_area(left, top, width, height);
+              inputWidth, inputHeight, baton->width, baton->height, baton->position);
+            int width = std::min(inputWidth, baton->width);
+            int height = std::min(inputHeight, baton->height);
+
+            image = nPages > 1
+              ? sharp::CropMultiPage(image,
+                  left, top, width, height, nPages, &targetPageHeight)
+              : image.extract_area(left, top, width, height);
           } else {
             // Attention-based or Entropy-based crop
-            if (baton->width > image.width()) {
-              baton->width = image.width();
-            }
-            if (baton->height > image.height()) {
-              baton->height = image.height();
-            }
+            MultiPageUnsupported(nPages, "Resize strategy");
             image = image.tilecache(VImage::option()
               ->set("access", VIPS_ACCESS_RANDOM)
               ->set("threaded", TRUE));
@@ -479,21 +506,32 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Rotate post-extract non-90 angle
       if (!baton->rotateBeforePreExtract && baton->rotationAngle != 0.0) {
+        MultiPageUnsupported(nPages, "Rotate");
         std::vector<double> background;
-        std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground);
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, shouldPremultiplyAlpha);
         image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
       }
 
       // Post extraction
       if (baton->topOffsetPost != -1) {
-        image = image.extract_area(
-          baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost);
+        if (nPages > 1) {
+          image = sharp::CropMultiPage(image,
+            baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost,
+            nPages, &targetPageHeight);
+
+          // heightPost is used in the info object, so update to reflect the number of pages
+          baton->heightPost *= nPages;
+        } else {
+          image = image.extract_area(
+            baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost);
+        }
       }
 
       // Affine transform
       if (baton->affineMatrix.size() > 0) {
+        MultiPageUnsupported(nPages, "Affine");
         std::vector<double> background;
-        std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground);
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground, shouldPremultiplyAlpha);
         image = image.affine(baton->affineMatrix, VImage::option()->set("background", background)
           ->set("idx", baton->affineIdx)
           ->set("idy", baton->affineIdy)
@@ -505,14 +543,17 @@ 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);
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground, shouldPremultiplyAlpha);
 
         // Embed
         baton->width = image.width() + baton->extendLeft + baton->extendRight;
-        baton->height = image.height() + baton->extendTop + baton->extendBottom;
+        baton->height = (nPages > 1 ? targetPageHeight : image.height()) + baton->extendTop + baton->extendBottom;
 
-        image = image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
-          VImage::option()->set("extend", VIPS_EXTEND_BACKGROUND)->set("background", background));
+        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));
       }
       // Median - must happen before blurring, due to the utility of blurring after thresholding
       if (shouldApplyMedian) {
@@ -542,7 +583,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       if (shouldModulate) {
-        image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue);
+        image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue, baton->lightness);
       }
 
       // Sharpen
@@ -715,9 +756,10 @@ class PipelineWorker : public Napi::AsyncWorker {
         // Convert colourspace, pass the current known interpretation so libvips doesn't have to guess
         image = image.colourspace(baton->colourspace, VImage::option()->set("source_space", image.interpretation()));
         // Transform colours from embedded profile to output profile
-        if (baton->withMetadata && sharp::HasProfile(image)) {
-          image = image.icc_transform(vips_enum_nick(VIPS_TYPE_INTERPRETATION, baton->colourspace),
-            VImage::option()->set("embedded", TRUE));
+        if (baton->withMetadata && sharp::HasProfile(image) && baton->withMetadataIcc.empty()) {
+          image = image.icc_transform("srgb", VImage::option()
+            ->set("embedded", TRUE)
+            ->set("intent", VIPS_INTENT_PERCEPTUAL));
         }
       }
 
@@ -726,7 +768,8 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.icc_transform(
           const_cast<char*>(baton->withMetadataIcc.data()),
           VImage::option()
-            ->set("input_profile", "srgb")
+            ->set("input_profile", processingProfile)
+            ->set("embedded", TRUE)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
       }
       // Override EXIF Orientation tag
@@ -750,16 +793,11 @@ class PipelineWorker : public Napi::AsyncWorker {
       baton->width = image.width();
       baton->height = image.height();
 
-      bool const supportsGifOutput = vips_type_find("VipsOperation", "magicksave") != 0 &&
-       vips_type_find("VipsOperation", "magicksave_buffer") != 0;
-
       image = sharp::SetAnimationProperties(
-        image,
-        baton->pageHeight,
-        baton->delay,
-        baton->loop);
+        image, nPages, targetPageHeight, baton->delay, baton->loop);
 
       // Output
+      sharp::SetTimeout(image, baton->timeoutSeconds);
       if (baton->fileOut.empty()) {
         // Buffer output
         if (baton->formatOut == "jpeg" || (baton->formatOut == "input" && inputImageType == sharp::ImageType::JPEG)) {
@@ -787,9 +825,24 @@ class PipelineWorker : public Napi::AsyncWorker {
           } else {
             baton->channels = std::min(baton->channels, 3);
           }
+        } else if (baton->formatOut == "jp2" || (baton->formatOut == "input"
+          && inputImageType == sharp::ImageType::JP2)) {
+          // Write JP2 to Buffer
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JP2);
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.jp2ksave_buffer(VImage::option()
+            ->set("Q", baton->jp2Quality)
+            ->set("lossless", baton->jp2Lossless)
+            ->set("subsample_mode", baton->jp2ChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+            ->set("tile_height", baton->jp2TileHeight)
+            ->set("tile_width", baton->jp2TileWidth)));
+          baton->bufferOut = static_cast<char*>(area->data);
+          baton->bufferOutLength = area->length;
+          area->free_fn = nullptr;
+          vips_area_unref(area);
+          baton->formatOut = "jp2";
         } else if (baton->formatOut == "png" || (baton->formatOut == "input" &&
-          (inputImageType == sharp::ImageType::PNG || (inputImageType == sharp::ImageType::GIF && !supportsGifOutput) ||
-           inputImageType == sharp::ImageType::SVG))) {
+          (inputImageType == sharp::ImageType::PNG || inputImageType == sharp::ImageType::SVG))) {
           // Write PNG to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::PNG);
           VipsArea *area = reinterpret_cast<VipsArea*>(image.pngsave_buffer(VImage::option()
@@ -799,7 +852,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE)
             ->set("palette", baton->pngPalette)
             ->set("Q", baton->pngQuality)
-            ->set("colours", baton->pngColours)
+            ->set("effort", baton->pngEffort)
+            ->set("bitdepth", sharp::Is16Bit(image.interpretation()) ? 16 : baton->pngBitdepth)
             ->set("dither", baton->pngDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -816,7 +870,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("lossless", baton->webpLossless)
             ->set("near_lossless", baton->webpNearLossless)
             ->set("smart_subsample", baton->webpSmartSubsample)
-            ->set("reduction_effort", baton->webpReductionEffort)
+            ->set("effort", baton->webpEffort)
             ->set("alpha_q", baton->webpAlphaQuality)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -824,14 +878,14 @@ class PipelineWorker : public Napi::AsyncWorker {
           vips_area_unref(area);
           baton->formatOut = "webp";
         } else if (baton->formatOut == "gif" ||
-          (baton->formatOut == "input" && inputImageType == sharp::ImageType::GIF && supportsGifOutput)) {
+          (baton->formatOut == "input" && inputImageType == sharp::ImageType::GIF)) {
           // Write GIF to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::GIF);
-          VipsArea *area = reinterpret_cast<VipsArea*>(image.magicksave_buffer(VImage::option()
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.gifsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
-            ->set("optimize_gif_frames", TRUE)
-            ->set("optimize_gif_transparency", TRUE)
-            ->set("format", "gif")));
+            ->set("bitdepth", baton->gifBitdepth)
+            ->set("effort", baton->gifEffort)
+            ->set("dither", baton->gifDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
           area->free_fn = nullptr;
@@ -859,7 +913,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("tile_height", baton->tiffTileHeight)
             ->set("tile_width", baton->tiffTileWidth)
             ->set("xres", baton->tiffXres)
-            ->set("yres", baton->tiffYres)));
+            ->set("yres", baton->tiffYres)
+            ->set("resunit", baton->tiffResolutionUnit)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
           area->free_fn = nullptr;
@@ -868,11 +923,12 @@ class PipelineWorker : public Napi::AsyncWorker {
         } else if (baton->formatOut == "heif" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to buffer
+          image = sharp::RemoveAnimationProperties(image);
           VipsArea *area = reinterpret_cast<VipsArea*>(image.heifsave_buffer(VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->heifQuality)
             ->set("compression", baton->heifCompression)
-            ->set("speed", baton->heifSpeed)
+            ->set("effort", baton->heifEffort)
             ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("lossless", baton->heifLossless)));
@@ -917,13 +973,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         bool const isWebp = sharp::IsWebp(baton->fileOut);
         bool const isGif = sharp::IsGif(baton->fileOut);
         bool const isTiff = sharp::IsTiff(baton->fileOut);
+        bool const isJp2 = sharp::IsJp2(baton->fileOut);
         bool const isHeif = sharp::IsHeif(baton->fileOut);
         bool const isDz = sharp::IsDz(baton->fileOut);
         bool const isDzZip = sharp::IsDzZip(baton->fileOut);
         bool const isV = sharp::IsV(baton->fileOut);
         bool const mightMatchInput = baton->formatOut == "input";
         bool const willMatchInput = mightMatchInput &&
-         !(isJpeg || isPng || isWebp || isGif || isTiff || isHeif || isDz || isDzZip || isV);
+         !(isJpeg || isPng || isWebp || isGif || isTiff || isJp2 || isHeif || isDz || isDzZip || isV);
 
         if (baton->formatOut == "jpeg" || (mightMatchInput && isJpeg) ||
           (willMatchInput && inputImageType == sharp::ImageType::JPEG)) {
@@ -943,9 +1000,20 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("optimize_coding", baton->jpegOptimiseCoding));
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
+        } else if (baton->formatOut == "jp2" || (mightMatchInput && isJp2) ||
+          (willMatchInput && (inputImageType == sharp::ImageType::JP2))) {
+          // Write JP2 to file
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JP2);
+          image.jp2ksave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+            ->set("Q", baton->jp2Quality)
+            ->set("lossless", baton->jp2Lossless)
+            ->set("subsample_mode", baton->jp2ChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+            ->set("tile_height", baton->jp2TileHeight)
+            ->set("tile_width", baton->jp2TileWidth));
+            baton->formatOut = "jp2";
         } else if (baton->formatOut == "png" || (mightMatchInput && isPng) || (willMatchInput &&
-          (inputImageType == sharp::ImageType::PNG || (inputImageType == sharp::ImageType::GIF && !supportsGifOutput) ||
-           inputImageType == sharp::ImageType::SVG))) {
+          (inputImageType == sharp::ImageType::PNG || inputImageType == sharp::ImageType::SVG))) {
           // Write PNG to file
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::PNG);
           image.pngsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
@@ -955,7 +1023,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("filter", baton->pngAdaptiveFiltering ? VIPS_FOREIGN_PNG_FILTER_ALL : VIPS_FOREIGN_PNG_FILTER_NONE)
             ->set("palette", baton->pngPalette)
             ->set("Q", baton->pngQuality)
-            ->set("colours", baton->pngColours)
+            ->set("bitdepth", sharp::Is16Bit(image.interpretation()) ? 16 : baton->pngBitdepth)
+            ->set("effort", baton->pngEffort)
             ->set("dither", baton->pngDither));
           baton->formatOut = "png";
         } else if (baton->formatOut == "webp" || (mightMatchInput && isWebp) ||
@@ -968,18 +1037,18 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("lossless", baton->webpLossless)
             ->set("near_lossless", baton->webpNearLossless)
             ->set("smart_subsample", baton->webpSmartSubsample)
-            ->set("reduction_effort", baton->webpReductionEffort)
+            ->set("effort", baton->webpEffort)
             ->set("alpha_q", baton->webpAlphaQuality));
           baton->formatOut = "webp";
         } else if (baton->formatOut == "gif" || (mightMatchInput && isGif) ||
-          (willMatchInput && inputImageType == sharp::ImageType::GIF && supportsGifOutput)) {
+          (willMatchInput && inputImageType == sharp::ImageType::GIF)) {
           // Write GIF to file
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::GIF);
-          image.magicksave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+          image.gifsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
-            ->set("optimize_gif_frames", TRUE)
-            ->set("optimize_gif_transparency", TRUE)
-            ->set("format", "gif"));
+            ->set("bitdepth", baton->gifBitdepth)
+            ->set("effort", baton->gifEffort)
+            ->set("dither", baton->gifDither));
           baton->formatOut = "gif";
         } else if (baton->formatOut == "tiff" || (mightMatchInput && isTiff) ||
           (willMatchInput && inputImageType == sharp::ImageType::TIFF)) {
@@ -1003,16 +1072,18 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("tile_height", baton->tiffTileHeight)
             ->set("tile_width", baton->tiffTileWidth)
             ->set("xres", baton->tiffXres)
-            ->set("yres", baton->tiffYres));
+            ->set("yres", baton->tiffYres)
+            ->set("resunit", baton->tiffResolutionUnit));
           baton->formatOut = "tiff";
         } else if (baton->formatOut == "heif" || (mightMatchInput && isHeif) ||
           (willMatchInput && inputImageType == sharp::ImageType::HEIF)) {
           // Write HEIF to file
+          image = sharp::RemoveAnimationProperties(image);
           image.heifsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->heifQuality)
             ->set("compression", baton->heifCompression)
-            ->set("speed", baton->heifSpeed)
+            ->set("effort", baton->heifEffort)
             ->set("subsample_mode", baton->heifChromaSubsampling == "4:4:4"
               ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
             ->set("lossless", baton->heifLossless));
@@ -1037,7 +1108,7 @@ class PipelineWorker : public Napi::AsyncWorker {
               {"lossless", baton->webpLossless ? "TRUE" : "FALSE"},
               {"near_lossless", baton->webpNearLossless ? "TRUE" : "FALSE"},
               {"smart_subsample", baton->webpSmartSubsample ? "TRUE" : "FALSE"},
-              {"reduction_effort", std::to_string(baton->webpReductionEffort)}
+              {"effort", std::to_string(baton->webpEffort)}
             };
             suffix = AssembleSuffixString(".webp", options);
           } else {
@@ -1186,6 +1257,12 @@ class PipelineWorker : public Napi::AsyncWorker {
   Napi::FunctionReference debuglog;
   Napi::FunctionReference queueListener;
 
+  void MultiPageUnsupported(int const pages, std::string op) {
+    if (pages > 1) {
+      throw vips::VError(op + " is not supported for multi-page images");
+    }
+  }
+
   /*
     Calculate the angle of rotation and need-to-flip for the given Exif orientation
     By default, returns zero, i.e. no rotation.
@@ -1276,15 +1353,15 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   // Canvas option
   std::string canvas = sharp::AttrAsStr(options, "canvas");
   if (canvas == "crop") {
-    baton->canvas = Canvas::CROP;
+    baton->canvas = sharp::Canvas::CROP;
   } else if (canvas == "embed") {
-    baton->canvas = Canvas::EMBED;
+    baton->canvas = sharp::Canvas::EMBED;
   } else if (canvas == "max") {
-    baton->canvas = Canvas::MAX;
+    baton->canvas = sharp::Canvas::MAX;
   } else if (canvas == "min") {
-    baton->canvas = Canvas::MIN;
+    baton->canvas = sharp::Canvas::MIN;
   } else if (canvas == "ignore_aspect") {
-    baton->canvas = Canvas::IGNORE_ASPECT;
+    baton->canvas = sharp::Canvas::IGNORE_ASPECT;
   }
   // Tint chroma
   baton->tintA = sharp::AttrAsDouble(options, "tintA");
@@ -1307,6 +1384,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   }
   // Resize options
   baton->withoutEnlargement = sharp::AttrAsBool(options, "withoutEnlargement");
+  baton->withoutReduction = sharp::AttrAsBool(options, "withoutReduction");
   baton->position = sharp::AttrAsInt32(options, "position");
   baton->resizeBackground = sharp::AttrAsVectorOfDouble(options, "resizeBackground");
   baton->kernel = sharp::AttrAsStr(options, "kernel");
@@ -1328,6 +1406,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->brightness = sharp::AttrAsDouble(options, "brightness");
   baton->saturation = sharp::AttrAsDouble(options, "saturation");
   baton->hue = sharp::AttrAsInt32(options, "hue");
+  baton->lightness = sharp::AttrAsDouble(options, "lightness");
   baton->medianSize = sharp::AttrAsUint32(options, "medianSize");
   baton->sharpenSigma = sharp::AttrAsDouble(options, "sharpenSigma");
   baton->sharpenFlat = sharp::AttrAsDouble(options, "sharpenFlat");
@@ -1364,7 +1443,6 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->affineOdx = sharp::AttrAsDouble(options, "affineOdx");
   baton->affineOdy = sharp::AttrAsDouble(options, "affineOdy");
   baton->affineInterpolator = vips::VInterpolate::new_from_name(sharp::AttrAsStr(options, "affineInterpolator").data());
-
   baton->removeAlpha = sharp::AttrAsBool(options, "removeAlpha");
   baton->ensureAlpha = sharp::AttrAsDouble(options, "ensureAlpha");
   if (options.Has("boolean")) {
@@ -1415,6 +1493,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     std::string k = sharp::AttrAsStr(mdStrKeys, i);
     baton->withMetadataStrs.insert(std::make_pair(k, sharp::AttrAsStr(mdStrs, k)));
   }
+  baton->timeoutSeconds = sharp::AttrAsUint32(options, "timeoutSeconds");
   // Format-specific
   baton->jpegQuality = sharp::AttrAsUint32(options, "jpegQuality");
   baton->jpegProgressive = sharp::AttrAsBool(options, "jpegProgressive");
@@ -1429,14 +1508,23 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->pngAdaptiveFiltering = sharp::AttrAsBool(options, "pngAdaptiveFiltering");
   baton->pngPalette = sharp::AttrAsBool(options, "pngPalette");
   baton->pngQuality = sharp::AttrAsUint32(options, "pngQuality");
-  baton->pngColours = sharp::AttrAsUint32(options, "pngColours");
+  baton->pngEffort = sharp::AttrAsUint32(options, "pngEffort");
+  baton->pngBitdepth = sharp::AttrAsUint32(options, "pngBitdepth");
   baton->pngDither = sharp::AttrAsDouble(options, "pngDither");
+  baton->jp2Quality = sharp::AttrAsUint32(options, "jp2Quality");
+  baton->jp2Lossless = sharp::AttrAsBool(options, "jp2Lossless");
+  baton->jp2TileHeight = sharp::AttrAsUint32(options, "jp2TileHeight");
+  baton->jp2TileWidth = sharp::AttrAsUint32(options, "jp2TileWidth");
+  baton->jp2ChromaSubsampling = sharp::AttrAsStr(options, "jp2ChromaSubsampling");
   baton->webpQuality = sharp::AttrAsUint32(options, "webpQuality");
   baton->webpAlphaQuality = sharp::AttrAsUint32(options, "webpAlphaQuality");
   baton->webpLossless = sharp::AttrAsBool(options, "webpLossless");
   baton->webpNearLossless = sharp::AttrAsBool(options, "webpNearLossless");
   baton->webpSmartSubsample = sharp::AttrAsBool(options, "webpSmartSubsample");
-  baton->webpReductionEffort = sharp::AttrAsUint32(options, "webpReductionEffort");
+  baton->webpEffort = sharp::AttrAsUint32(options, "webpEffort");
+  baton->gifBitdepth = sharp::AttrAsUint32(options, "gifBitdepth");
+  baton->gifEffort = sharp::AttrAsUint32(options, "gifEffort");
+  baton->gifDither = sharp::AttrAsDouble(options, "gifDither");
   baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");
   baton->tiffPyramid = sharp::AttrAsBool(options, "tiffPyramid");
   baton->tiffBitdepth = sharp::AttrAsUint32(options, "tiffBitdepth");
@@ -1445,6 +1533,9 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->tiffTileHeight = sharp::AttrAsUint32(options, "tiffTileHeight");
   baton->tiffXres = sharp::AttrAsDouble(options, "tiffXres");
   baton->tiffYres = sharp::AttrAsDouble(options, "tiffYres");
+  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,
@@ -1452,30 +1543,28 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   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->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->heifSpeed = sharp::AttrAsUint32(options, "heifSpeed");
+  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()));
-
-  // Animated output
-  if (sharp::HasAttr(options, "pageHeight")) {
-    baton->pageHeight = sharp::AttrAsUint32(options, "pageHeight");
-  }
+  // Animated output properties
   if (sharp::HasAttr(options, "loop")) {
     baton->loop = sharp::AttrAsUint32(options, "loop");
   }
   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");