sharp 0.20.5 → 0.21.0

package/src/metadata.cc

@@ -62,6 +62,12 @@ class MetadataWorker : public Nan::AsyncWorker {
       if (sharp::HasDensity(image)) {
         baton->density = sharp::GetDensity(image);
       }
+      if (image.get_typeof("jpeg-chroma-subsample") == VIPS_TYPE_REF_STRING) {
+        baton->chromaSubsampling = image.get_string("jpeg-chroma-subsample");
+      }
+      if (image.get_typeof("interlaced") == G_TYPE_INT) {
+        baton->isProgressive = image.get_int("interlaced") == 1;
+      }
       baton->hasProfile = sharp::HasProfile(image);
       // Derived attributes
       baton->hasAlpha = sharp::HasAlpha(image);
@@ -117,6 +123,9 @@ class MetadataWorker : public Nan::AsyncWorker {
       // Metadata Object
       v8::Local<v8::Object> info = New<v8::Object>();
       Set(info, New("format").ToLocalChecked(), New<v8::String>(baton->format).ToLocalChecked());
+      if (baton->input->bufferLength > 0) {
+        Set(info, New("size").ToLocalChecked(), New<v8::Uint32>(static_cast<uint32_t>(baton->input->bufferLength)));
+      }
       Set(info, New("width").ToLocalChecked(), New<v8::Uint32>(baton->width));
       Set(info, New("height").ToLocalChecked(), New<v8::Uint32>(baton->height));
       Set(info, New("space").ToLocalChecked(), New<v8::String>(baton->space).ToLocalChecked());
@@ -125,6 +134,12 @@ class MetadataWorker : public Nan::AsyncWorker {
       if (baton->density > 0) {
         Set(info, New("density").ToLocalChecked(), New<v8::Uint32>(baton->density));
       }
+      if (!baton->chromaSubsampling.empty()) {
+        Set(info,
+          New("chromaSubsampling").ToLocalChecked(),
+          New<v8::String>(baton->chromaSubsampling).ToLocalChecked());
+      }
+      Set(info, New("isProgressive").ToLocalChecked(), New<v8::Boolean>(baton->isProgressive));
       Set(info, New("hasProfile").ToLocalChecked(), New<v8::Boolean>(baton->hasProfile));
       Set(info, New("hasAlpha").ToLocalChecked(), New<v8::Boolean>(baton->hasAlpha));
       if (baton->orientation > 0) {

package/src/metadata.h

@@ -31,6 +31,8 @@ struct MetadataBaton {
   int channels;
   std::string depth;
   int density;
+  std::string chromaSubsampling;
+  bool isProgressive;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -50,6 +52,7 @@ struct MetadataBaton {
     height(0),
     channels(0),
     density(0),
+    isProgressive(false),
     hasProfile(false),
     hasAlpha(false),
     orientation(0),

package/src/operations.cc

@@ -28,6 +28,16 @@ using vips::VError;
 
 namespace sharp {
 
+  /*
+    Removes alpha channel, if any.
+  */
+  VImage RemoveAlpha(VImage image) {
+    if (HasAlpha(image)) {
+      image = image.extract_band(0, VImage::option()->set("n", image.bands() - 1));
+    }
+    return image;
+  }
+
   /*
     Composite overlayImage over image at given position
     Assumes alpha channels are already premultiplied and will be unpremultiplied after
@@ -68,7 +78,7 @@ namespace sharp {
     //
     // References:
     // - http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending
-    // - https://github.com/jcupitt/ruby-vips/issues/28#issuecomment-9014826
+    // - https://github.com/libvips/ruby-vips/issues/28#issuecomment-9014826
     //
     // out_a = src_a + dst_a * (1 - src_a)
     //                         ^^^^^^^^^^^
@@ -223,10 +233,8 @@ namespace sharp {
   VImage Gamma(VImage image, double const exponent) {
     if (HasAlpha(image)) {
       // Separate alpha channel
-      VImage imageWithoutAlpha = image.extract_band(0,
-        VImage::option()->set("n", image.bands() - 1));
       VImage alpha = image[image.bands() - 1];
-      return imageWithoutAlpha.gamma(VImage::option()->set("exponent", exponent)).bandjoin(alpha);
+      return RemoveAlpha(image).gamma(VImage::option()->set("exponent", exponent)).bandjoin(alpha);
     } else {
       return image.gamma(VImage::option()->set("exponent", exponent));
     }
@@ -316,55 +324,22 @@ namespace sharp {
     return image.boolean(imageR, boolean);
   }
 
-  VImage Trim(VImage image, int const tolerance) {
-    using sharp::MaximumImageAlpha;
-    // An equivalent of ImageMagick's -trim in C++ ... automatically remove
-    // "boring" image edges.
-
-    // We use .project to sum the rows and columns of a 0/255 mask image, the first
-    // non-zero row or column is the object edge. We make the mask image with an
-    // amount-different-from-background image plus a threshold.
-
-    // find the value of the pixel at (0, 0) ... we will search for all pixels
-    // significantly different from this
-    std::vector<double> background = image(0, 0);
-
-    double const max = MaximumImageAlpha(image.interpretation());
-
-    // we need to smooth the image, subtract the background from every pixel, take
-    // the absolute value of the difference, then threshold
-    VImage mask = (image.median(3) - background).abs() > (max * tolerance / 100);
-
-    // sum mask rows and columns, then search for the first non-zero sum in each
-    // direction
-    VImage rows;
-    VImage columns = mask.project(&rows);
-
-    VImage profileLeftV;
-    VImage profileLeftH = columns.profile(&profileLeftV);
-
-    VImage profileRightV;
-    VImage profileRightH = columns.fliphor().profile(&profileRightV);
-
-    VImage profileTopV;
-    VImage profileTopH = rows.profile(&profileTopV);
-
-    VImage profileBottomV;
-    VImage profileBottomH = rows.flipver().profile(&profileBottomV);
-
-    int left = static_cast<int>(floor(profileLeftV.min()));
-    int right = columns.width() - static_cast<int>(floor(profileRightV.min()));
-    int top = static_cast<int>(floor(profileTopH.min()));
-    int bottom = rows.height() - static_cast<int>(floor(profileBottomH.min()));
-
-    int width = right - left;
-    int height = bottom - top;
-
-    if (width <= 0 || height <= 0) {
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, double const threshold) {
+    // Top-left pixel provides the background colour
+    VImage background = image.extract_area(0, 0, 1, 1);
+    if (HasAlpha(background)) {
+      background = background.flatten();
+    }
+    int top, width, height;
+    int const left = image.find_trim(&top, &width, &height, VImage::option()
+      ->set("background", background(0, 0))
+      ->set("threshold", threshold));
+    if (width == 0 || height == 0) {
       throw VError("Unexpected error while trimming. Try to lower the tolerance");
     }
-
-    // and now crop the original image
     return image.extract_area(left, top, width, height);
   }
 
@@ -374,10 +349,8 @@ namespace sharp {
   VImage Linear(VImage image, double const a, double const b) {
     if (HasAlpha(image)) {
       // Separate alpha channel
-      VImage imageWithoutAlpha = image.extract_band(0,
-        VImage::option()->set("n", image.bands() - 1));
       VImage alpha = image[image.bands() - 1];
-      return imageWithoutAlpha.linear(a, b).bandjoin(alpha);
+      return RemoveAlpha(image).linear(a, b).bandjoin(alpha);
     } else {
       return image.linear(a, b);
     }

package/src/operations.h

@@ -25,6 +25,11 @@ using vips::VImage;
 
 namespace sharp {
 
+  /*
+    Removes alpha channel, if any.
+  */
+  VImage RemoveAlpha(VImage image);
+
   /*
     Alpha composite src over dst with given gravity.
     Assumes alpha channels are already premultiplied and will be unpremultiplied after.
@@ -95,7 +100,7 @@ namespace sharp {
   /*
     Trim an image
   */
-  VImage Trim(VImage image, int const tolerance);
+  VImage Trim(VImage image, double const threshold);
 
   /*
    * Linear adjustment (a * in + b)

package/src/pipeline.cc

@@ -100,8 +100,10 @@ class PipelineWorker : public Nan::AsyncWorker {
       }
 
       // Trim
-      if (baton->trimTolerance != 0) {
-        image = sharp::Trim(image, baton->trimTolerance);
+      if (baton->trimThreshold > 0.0) {
+        image = sharp::Trim(image, baton->trimThreshold);
+        baton->trimOffsetLeft = image.xoffset();
+        baton->trimOffsetTop = image.yoffset();
       }
 
       // Pre extraction
@@ -233,7 +235,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       if (
         xshrink == yshrink && xshrink >= 2 * shrink_on_load_factor &&
         (inputImageType == ImageType::JPEG || inputImageType == ImageType::WEBP) &&
-        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimTolerance == 0
+        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0
       ) {
         if (xshrink >= 8 * shrink_on_load_factor) {
           xfactor = xfactor / 8;
@@ -318,9 +320,9 @@ class PipelineWorker : public Nan::AsyncWorker {
         double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
         // Background colour
         std::vector<double> background {
-          baton->background[0] * multiplier,
-          baton->background[1] * multiplier,
-          baton->background[2] * multiplier
+          baton->flattenBackground[0] * multiplier,
+          baton->flattenBackground[1] * multiplier,
+          baton->flattenBackground[2] * multiplier
         };
         image = image.flatten(VImage::option()
           ->set("background", background));
@@ -421,35 +423,8 @@ class PipelineWorker : public Nan::AsyncWorker {
       // Crop/embed
       if (image.width() != baton->width || image.height() != baton->height) {
         if (baton->canvas == Canvas::EMBED) {
-          // Scale up 8-bit values to match 16-bit input image
-          double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
-          // Create background colour
           std::vector<double> background;
-          if (image.bands() > 2) {
-            background = {
-              multiplier * baton->background[0],
-              multiplier * baton->background[1],
-              multiplier * baton->background[2]
-            };
-          } else {
-            // Convert sRGB to greyscale
-            background = { multiplier * (
-              0.2126 * baton->background[0] +
-              0.7152 * baton->background[1] +
-              0.0722 * baton->background[2])
-            };
-          }
-          // Add alpha channel to background colour
-          if (baton->background[3] < 255.0 || HasAlpha(image)) {
-            background.push_back(baton->background[3] * multiplier);
-          }
-          // Ensure background colour uses correct colourspace
-          background = sharp::GetRgbaAsColourspace(background, image.interpretation());
-          // Add non-transparent alpha channel, if required
-          if (baton->background[3] < 255.0 && !HasAlpha(image)) {
-            image = image.bandjoin(
-              VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
-          }
+          std::tie(image, background) = sharp::ApplyAlpha(image, baton->resizeBackground);
 
           // Embed
 
@@ -463,7 +438,7 @@ class PipelineWorker : public Nan::AsyncWorker {
           int width = std::max(image.width(), baton->width);
           int height = std::max(image.height(), baton->height);
           std::tie(left, top) = sharp::CalculateEmbedPosition(
-            image.width(), image.height(), baton->width, baton->height, baton->embed);
+            image.width(), image.height(), baton->width, baton->height, baton->position);
 
           image = image.embed(left, top, width, height, VImage::option()
             ->set("extend", VIPS_EXTEND_BACKGROUND)
@@ -474,12 +449,12 @@ class PipelineWorker : public Nan::AsyncWorker {
           (image.width() > baton->width || image.height() > baton->height)
         ) {
           // Crop/max/min
-          if (baton->crop < 9) {
+          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->crop);
+              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);
@@ -495,7 +470,7 @@ class PipelineWorker : public Nan::AsyncWorker {
               ->set("access", baton->accessMethod)
               ->set("threaded", TRUE));
             image = image.smartcrop(baton->width, baton->height, VImage::option()
-              ->set("interesting", baton->crop == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION));
+              ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION));
             baton->hasCropOffset = true;
             baton->cropOffsetLeft = static_cast<int>(image.xoffset());
             baton->cropOffsetTop = static_cast<int>(image.yoffset());
@@ -503,6 +478,13 @@ class PipelineWorker : public Nan::AsyncWorker {
         }
       }
 
+      // Rotate by degree
+      if (baton->rotationAngle != 0.0) {
+        std::vector<double> background;
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground);
+        image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
+      }
+
       // Post extraction
       if (baton->topOffsetPost != -1) {
         image = image.extract_area(
@@ -511,35 +493,9 @@ class PipelineWorker : public Nan::AsyncWorker {
 
       // Extend edges
       if (baton->extendTop > 0 || baton->extendBottom > 0 || baton->extendLeft > 0 || baton->extendRight > 0) {
-        // Scale up 8-bit values to match 16-bit input image
-        double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
-        // Create background colour
         std::vector<double> background;
-        if (image.bands() > 2) {
-          background = {
-            multiplier * baton->background[0],
-            multiplier * baton->background[1],
-            multiplier * baton->background[2]
-          };
-        } else {
-          // Convert sRGB to greyscale
-          background = { multiplier * (
-            0.2126 * baton->background[0] +
-            0.7152 * baton->background[1] +
-            0.0722 * baton->background[2])
-          };
-        }
-        // Add alpha channel to background colour
-        if (baton->background[3] < 255.0 || HasAlpha(image)) {
-          background.push_back(baton->background[3] * multiplier);
-        }
-        // Ensure background colour uses correct colourspace
-        background = sharp::GetRgbaAsColourspace(background, image.interpretation());
-        // Add non-transparent alpha channel, if required
-        if (baton->background[3] < 255.0 && !HasAlpha(image)) {
-          image = image.bandjoin(
-            VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
-        }
+        std::tie(image, background) = sharp::ApplyAlpha(image, baton->extendBackground);
+
         // Embed
         baton->width = image.width() + baton->extendLeft + baton->extendRight;
         baton->height = image.height() + baton->extendTop + baton->extendBottom;
@@ -694,10 +650,19 @@ class PipelineWorker : public Nan::AsyncWorker {
           (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", VIPS_INTERPRETATION_B_W));
+          .copy(VImage::option()->set("interpretation", interpretation));
+      }
+
+      // Remove alpha channel, if any
+      if (baton->removeAlpha) {
+        image = sharp::RemoveAlpha(image);
       }
+
       // Convert image to sRGB, if not already
       if (sharp::Is16Bit(image.interpretation())) {
         image = image.cast(VIPS_FORMAT_USHORT);
@@ -733,6 +698,7 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("interlace", baton->jpegProgressive)
             ->set("no_subsample", baton->jpegChromaSubsampling == "4:4:4")
             ->set("trellis_quant", baton->jpegTrellisQuantisation)
+            ->set("quant_table", baton->jpegQuantisationTable)
             ->set("overshoot_deringing", baton->jpegOvershootDeringing)
             ->set("optimize_scans", baton->jpegOptimiseScans)
             ->set("optimize_coding", baton->jpegOptimiseCoding)));
@@ -848,6 +814,7 @@ class PipelineWorker : public Nan::AsyncWorker {
             ->set("interlace", baton->jpegProgressive)
             ->set("no_subsample", baton->jpegChromaSubsampling == "4:4:4")
             ->set("trellis_quant", baton->jpegTrellisQuantisation)
+            ->set("quant_table", baton->jpegQuantisationTable)
             ->set("overshoot_deringing", baton->jpegOvershootDeringing)
             ->set("optimize_scans", baton->jpegOptimiseScans)
             ->set("optimize_coding", baton->jpegOptimiseCoding));
@@ -883,10 +850,6 @@ class PipelineWorker : public Nan::AsyncWorker {
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
             sharp::AssertImageTypeDimensions(image, ImageType::JPEG);
           }
-          // Cast pixel values to float, if required
-          if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
-            image = image.cast(VIPS_FORMAT_FLOAT);
-          }
           image.tiffsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
             ->set("strip", !baton->withMetadata)
             ->set("Q", baton->tiffQuality)
@@ -927,6 +890,7 @@ class PipelineWorker : public Nan::AsyncWorker {
               {"interlace", baton->jpegProgressive ? "TRUE" : "FALSE"},
               {"no_subsample", baton->jpegChromaSubsampling == "4:4:4" ? "TRUE": "FALSE"},
               {"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"}
@@ -934,14 +898,22 @@ class PipelineWorker : public Nan::AsyncWorker {
             suffix = AssembleSuffixString(extname, options);
           }
           // Write DZ to file
-          image.dzsave(const_cast<char*>(baton->fileOut.data()), 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)));
+          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));
+
+          // 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);
+          }
+
+          image.dzsave(const_cast<char*>(baton->fileOut.data()), options);
           baton->formatOut = "dz";
         } else if (baton->formatOut == "v" || (mightMatchInput && isV) ||
           (willMatchInput && inputImageType == ImageType::VIPS)) {
@@ -996,6 +968,12 @@ class PipelineWorker : public Nan::AsyncWorker {
         Set(info, New("cropOffsetTop").ToLocalChecked(),
           New<v8::Int32>(static_cast<int32_t>(baton->cropOffsetTop)));
       }
+      if (baton->trimThreshold > 0.0) {
+        Set(info, New("trimOffsetLeft").ToLocalChecked(),
+          New<v8::Int32>(static_cast<int32_t>(baton->trimOffsetLeft)));
+        Set(info, New("trimOffsetTop").ToLocalChecked(),
+          New<v8::Int32>(static_cast<int32_t>(baton->trimOffsetTop)));
+      }
 
       if (baton->bufferOutLength > 0) {
         // Pass ownership of output data to Buffer instance
@@ -1127,6 +1105,7 @@ NAN_METHOD(pipeline) {
   using sharp::AttrTo;
   using sharp::AttrAs;
   using sharp::AttrAsStr;
+  using sharp::AttrAsRgba;
   using sharp::CreateInputDescriptor;
 
   // Input Buffers must not undergo GC compaction during processing
@@ -1170,11 +1149,6 @@ NAN_METHOD(pipeline) {
   } else if (canvas == "ignore_aspect") {
     baton->canvas = Canvas::IGNORE_ASPECT;
   }
-  // Background colour
-  v8::Local<v8::Object> background = AttrAs<v8::Object>(options, "background");
-  for (unsigned int i = 0; i < 4; i++) {
-    baton->background[i] = AttrTo<double>(background, i);
-  }
   // Tint chroma
   baton->tintA = AttrTo<double>(options, "tintA");
   baton->tintB = AttrTo<double>(options, "tintB");
@@ -1189,8 +1163,8 @@ NAN_METHOD(pipeline) {
   }
   // Resize options
   baton->withoutEnlargement = AttrTo<bool>(options, "withoutEnlargement");
-  baton->crop = AttrTo<int32_t>(options, "crop");
-  baton->embed = AttrTo<int32_t>(options, "embed");
+  baton->position = AttrTo<int32_t>(options, "position");
+  baton->resizeBackground = AttrAsRgba(options, "resizeBackground");
   baton->kernel = AttrAsStr(options, "kernel");
   baton->fastShrinkOnLoad = AttrTo<bool>(options, "fastShrinkOnLoad");
   // Join Channel Options
@@ -1208,6 +1182,7 @@ NAN_METHOD(pipeline) {
   }
   // Operators
   baton->flatten = AttrTo<bool>(options, "flatten");
+  baton->flattenBackground = AttrAsRgba(options, "flattenBackground");
   baton->negate = AttrTo<bool>(options, "negate");
   baton->blurSigma = AttrTo<double>(options, "blurSigma");
   baton->medianSize = AttrTo<uint32_t>(options, "medianSize");
@@ -1216,7 +1191,7 @@ NAN_METHOD(pipeline) {
   baton->sharpenJagged = AttrTo<double>(options, "sharpenJagged");
   baton->threshold = AttrTo<int32_t>(options, "threshold");
   baton->thresholdGrayscale = AttrTo<bool>(options, "thresholdGrayscale");
-  baton->trimTolerance = AttrTo<int32_t>(options, "trimTolerance");
+  baton->trimThreshold = AttrTo<double>(options, "trimThreshold");
   baton->gamma = AttrTo<double>(options, "gamma");
   baton->linearA = AttrTo<double>(options, "linearA");
   baton->linearB = AttrTo<double>(options, "linearB");
@@ -1224,6 +1199,8 @@ NAN_METHOD(pipeline) {
   baton->normalise = AttrTo<bool>(options, "normalise");
   baton->useExifOrientation = AttrTo<bool>(options, "useExifOrientation");
   baton->angle = AttrTo<int32_t>(options, "angle");
+  baton->rotationAngle = AttrTo<double>(options, "rotationAngle");
+  baton->rotationBackground = AttrAsRgba(options, "rotationBackground");
   baton->rotateBeforePreExtract = AttrTo<bool>(options, "rotateBeforePreExtract");
   baton->flip = AttrTo<bool>(options, "flip");
   baton->flop = AttrTo<bool>(options, "flop");
@@ -1231,7 +1208,10 @@ NAN_METHOD(pipeline) {
   baton->extendBottom = AttrTo<int32_t>(options, "extendBottom");
   baton->extendLeft = AttrTo<int32_t>(options, "extendLeft");
   baton->extendRight = AttrTo<int32_t>(options, "extendRight");
+  baton->extendBackground = AttrAsRgba(options, "extendBackground");
   baton->extractChannel = AttrTo<int32_t>(options, "extractChannel");
+
+  baton->removeAlpha = AttrTo<bool>(options, "removeAlpha");
   if (HasAttr(options, "boolean")) {
     baton->boolean = CreateInputDescriptor(AttrAs<v8::Object>(options, "boolean"), buffersToPersist);
     baton->booleanOp = sharp::GetBooleanOperation(AttrAsStr(options, "booleanOp"));
@@ -1266,6 +1246,7 @@ NAN_METHOD(pipeline) {
   baton->jpegProgressive = AttrTo<bool>(options, "jpegProgressive");
   baton->jpegChromaSubsampling = AttrAsStr(options, "jpegChromaSubsampling");
   baton->jpegTrellisQuantisation = AttrTo<bool>(options, "jpegTrellisQuantisation");
+  baton->jpegQuantisationTable = AttrTo<uint32_t>(options, "jpegQuantisationTable");
   baton->jpegOvershootDeringing = AttrTo<bool>(options, "jpegOvershootDeringing");
   baton->jpegOptimiseScans = AttrTo<bool>(options, "jpegOptimiseScans");
   baton->jpegOptimiseCoding = AttrTo<bool>(options, "jpegOptimiseCoding");
@@ -1307,10 +1288,21 @@ NAN_METHOD(pipeline) {
     baton->tileLayout = VIPS_FOREIGN_DZ_LAYOUT_DZ;
   }
   baton->tileFormat = AttrAsStr(options, "tileFormat");
+  std::string tileDepth = AttrAsStr(options, "tileDepth");
+  if (tileDepth == "onetile") {
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONETILE;
+  } else if (tileDepth == "one") {
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONE;
+  } else if (tileDepth == "onepixel") {
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL;
+  } else {
+    // signal that we do not want to pass any value to dzSave
+    baton->tileDepth = VIPS_FOREIGN_DZ_DEPTH_LAST;
+  }
   // Force random access for certain operations
   if (baton->accessMethod == VIPS_ACCESS_SEQUENTIAL && (
-    baton->trimTolerance != 0 || baton->normalise ||
-    baton->crop == 16 || baton->crop == 17)) {
+    baton->trimThreshold > 0.0 || baton->normalise ||
+    baton->position == 16 || baton->position == 17)) {
     baton->accessMethod = VIPS_ACCESS_RANDOM;
   }