@revizly/sharp 0.34.1-revizly8 → 0.34.4-revizly1

package/src/pipeline.cc

@@ -92,31 +92,22 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Calculate angle of rotation
       VipsAngle rotation = VIPS_ANGLE_D0;
       VipsAngle autoRotation = VIPS_ANGLE_D0;
-      bool autoFlip = false;
       bool autoFlop = false;
 
       if (baton->input->autoOrient) {
         // Rotate and flip image according to Exif orientation
-        std::tie(autoRotation, autoFlip, autoFlop) = CalculateExifRotationAndFlip(sharp::ExifOrientation(image));
-        image = sharp::RemoveExifOrientation(image);
+        std::tie(autoRotation, autoFlop) = CalculateExifRotationAndFlop(sharp::ExifOrientation(image));
       }
 
       rotation = CalculateAngleRotation(baton->angle);
 
-      // Rotate pre-extract
-      bool const shouldRotateBefore = baton->rotateBeforePreExtract &&
-        (rotation != VIPS_ANGLE_D0 || autoRotation != VIPS_ANGLE_D0 ||
-          autoFlip || baton->flip || autoFlop || baton->flop ||
-          baton->rotationAngle != 0.0);
-
-      if (shouldRotateBefore) {
-        image = sharp::StaySequential(image,
-          rotation != VIPS_ANGLE_D0 ||
-          autoRotation != VIPS_ANGLE_D0 ||
-          autoFlip ||
-          baton->flip ||
-          baton->rotationAngle != 0.0);
+      bool const shouldRotateBefore = baton->rotateBefore &&
+        (rotation != VIPS_ANGLE_D0 || baton->flip || baton->flop || baton->rotationAngle != 0.0);
+      bool const shouldOrientBefore = (shouldRotateBefore || baton->orientBefore) &&
+        (autoRotation != VIPS_ANGLE_D0 || autoFlop);
 
+      if (shouldOrientBefore) {
+        image = sharp::StaySequential(image, autoRotation != VIPS_ANGLE_D0);
         if (autoRotation != VIPS_ANGLE_D0) {
           if (autoRotation != VIPS_ANGLE_D180) {
             MultiPageUnsupported(nPages, "Rotate");
@@ -124,14 +115,20 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = image.rot(autoRotation);
           autoRotation = VIPS_ANGLE_D0;
         }
-        if (autoFlip != baton->flip) {
+        if (autoFlop) {
+          image = image.flip(VIPS_DIRECTION_HORIZONTAL);
+          autoFlop = false;
+        }
+      }
+
+      if (shouldRotateBefore) {
+        image = sharp::StaySequential(image, rotation != VIPS_ANGLE_D0 || baton->flip || baton->rotationAngle != 0.0);
+        if (baton->flip) {
           image = image.flip(VIPS_DIRECTION_VERTICAL);
-          autoFlip = false;
           baton->flip = false;
         }
-        if (autoFlop != baton->flop) {
+        if (baton->flop) {
           image = image.flip(VIPS_DIRECTION_HORIZONTAL);
-          autoFlop = false;
           baton->flop = false;
         }
         if (rotation != VIPS_ANGLE_D0) {
@@ -146,6 +143,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           std::vector<double> background;
           std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, false);
           image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background)).copy_memory();
+          baton->rotationAngle = 0.0;
         }
       }
 
@@ -184,8 +182,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // When auto-rotating by 90 or 270 degrees, swap the target width and
       // height to ensure the behavior aligns with how it would have been if
       // the rotation had taken place *before* resizing.
-      if (!baton->rotateBeforePreExtract &&
-        (autoRotation == VIPS_ANGLE_D90 || autoRotation == VIPS_ANGLE_D270)) {
+      if (autoRotation == VIPS_ANGLE_D90 || autoRotation == VIPS_ANGLE_D270) {
         std::swap(targetResizeWidth, targetResizeHeight);
       }
 
@@ -207,7 +204,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       //  - input colourspace is not specified;
       bool const shouldPreShrink = (targetResizeWidth > 0 || targetResizeHeight > 0) &&
         baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold < 0.0 &&
-        baton->colourspacePipeline == VIPS_INTERPRETATION_LAST && !shouldRotateBefore;
+        baton->colourspacePipeline == VIPS_INTERPRETATION_LAST && !(shouldOrientBefore || shouldRotateBefore);
 
       if (shouldPreShrink) {
         // The common part of the shrink: the bit by which both axes must be shrunk
@@ -241,11 +238,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       // factor for jpegload*, a double scale factor for webpload*,
       // pdfload* and svgload*
       if (jpegShrinkOnLoad > 1) {
-        vips::VOption *option = VImage::option()
-          ->set("access", access)
-          ->set("shrink", jpegShrinkOnLoad)
-          ->set("unlimited", baton->input->unlimited)
-          ->set("fail_on", baton->input->failOn);
+        vips::VOption *option = GetOptionsForImageType(inputImageType, baton->input)->set("shrink", jpegShrinkOnLoad);
         if (baton->input->buffer != nullptr) {
           // Reload JPEG buffer
           VipsBlob *blob = vips_blob_new(nullptr, baton->input->buffer, baton->input->bufferLength);
@@ -256,14 +249,8 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = VImage::jpegload(const_cast<char*>(baton->input->file.data()), option);
         }
       } else if (scale != 1.0) {
-        vips::VOption *option = VImage::option()
-          ->set("access", access)
-          ->set("scale", scale)
-          ->set("fail_on", baton->input->failOn);
+        vips::VOption *option = GetOptionsForImageType(inputImageType, baton->input)->set("scale", scale);
         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);
@@ -274,9 +261,6 @@ class PipelineWorker : public Napi::AsyncWorker {
             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);
@@ -291,10 +275,6 @@ class PipelineWorker : public Napi::AsyncWorker {
             throw vips::VError("Input SVG image will exceed 32767x32767 pixel limit when scaled");
           }
         } 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);
@@ -304,7 +284,6 @@ class PipelineWorker : public Napi::AsyncWorker {
             // Reload PDF file
             image = VImage::pdfload(const_cast<char*>(baton->input->file.data()), option);
           }
-
           sharp::SetDensity(image, baton->input->density);
         }
       } else {
@@ -312,6 +291,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           throw vips::VError("Input SVG image exceeds 32767x32767 pixel limit");
         }
       }
+      if (baton->input->autoOrient) {
+        image = sharp::RemoveExifOrientation(image);
+      }
 
       // Any pre-shrinking may already have been done
       inputWidth = image.width();
@@ -414,7 +396,6 @@ class PipelineWorker : public Napi::AsyncWorker {
       image = sharp::StaySequential(image,
         autoRotation != VIPS_ANGLE_D0 ||
         baton->flip ||
-        autoFlip ||
         rotation != VIPS_ANGLE_D0);
       // Auto-rotate post-extract
       if (autoRotation != VIPS_ANGLE_D0) {
@@ -424,7 +405,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.rot(autoRotation);
       }
       // Mirror vertically (up-down) about the x-axis
-      if (baton->flip != autoFlip) {
+      if (baton->flip) {
         image = image.flip(VIPS_DIRECTION_VERTICAL);
       }
       // Mirror horizontally (left-right) about the y-axis
@@ -531,7 +512,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Rotate post-extract non-90 angle
-      if (!baton->rotateBeforePreExtract && baton->rotationAngle != 0.0) {
+      if (!baton->rotateBefore && baton->rotationAngle != 0.0) {
         MultiPageUnsupported(nPages, "Rotate");
         image = sharp::StaySequential(image);
         std::vector<double> background;
@@ -668,26 +649,20 @@ class PipelineWorker : public Napi::AsyncWorker {
           sharp::ImageType compositeImageType = sharp::ImageType::UNKNOWN;
           composite->input->access = access;
           std::tie(compositeImage, compositeImageType) = sharp::OpenInput(composite->input);
-          compositeImage = sharp::EnsureColourspace(compositeImage, baton->colourspacePipeline);
 
           if (composite->input->autoOrient) {
             // Respect EXIF Orientation
             VipsAngle compositeAutoRotation = VIPS_ANGLE_D0;
-            bool compositeAutoFlip = false;
             bool compositeAutoFlop = false;
-            std::tie(compositeAutoRotation, compositeAutoFlip, compositeAutoFlop) =
-              CalculateExifRotationAndFlip(sharp::ExifOrientation(compositeImage));
+            std::tie(compositeAutoRotation, compositeAutoFlop) =
+              CalculateExifRotationAndFlop(sharp::ExifOrientation(compositeImage));
 
             compositeImage = sharp::RemoveExifOrientation(compositeImage);
-            compositeImage = sharp::StaySequential(compositeImage,
-              compositeAutoRotation != VIPS_ANGLE_D0 || compositeAutoFlip);
+            compositeImage = sharp::StaySequential(compositeImage, compositeAutoRotation != VIPS_ANGLE_D0);
 
             if (compositeAutoRotation != VIPS_ANGLE_D0) {
               compositeImage = compositeImage.rot(compositeAutoRotation);
             }
-            if (compositeAutoFlip) {
-              compositeImage = compositeImage.flip(VIPS_DIRECTION_VERTICAL);
-            }
             if (compositeAutoFlop) {
               compositeImage = compositeImage.flip(VIPS_DIRECTION_HORIZONTAL);
             }
@@ -733,8 +708,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             // gravity was used for extract_area, set it back to its default value of 0
             composite->gravity = 0;
           }
-          // Ensure image to composite is sRGB with unpremultiplied alpha
-          compositeImage = compositeImage.colourspace(VIPS_INTERPRETATION_sRGB);
+          // Ensure image to composite is with unpremultiplied alpha
           compositeImage = sharp::EnsureAlpha(compositeImage, 1);
           if (composite->premultiplied) compositeImage = compositeImage.unpremultiply();
           // Calculate position
@@ -759,7 +733,12 @@ class PipelineWorker : public Napi::AsyncWorker {
           xs.push_back(left);
           ys.push_back(top);
         }
-        image = VImage::composite(images, modes, VImage::option()->set("x", xs)->set("y", ys));
+        image = VImage::composite(images, modes, VImage::option()
+          ->set("compositing_space", baton->colourspacePipeline == VIPS_INTERPRETATION_LAST
+            ? VIPS_INTERPRETATION_sRGB
+            : baton->colourspacePipeline)
+          ->set("x", xs)
+          ->set("y", ys));
         image = sharp::RemoveGifPalette(image);
       }
 
@@ -891,7 +870,12 @@ class PipelineWorker : public Napi::AsyncWorker {
           image.set(s.first.data(), s.second.data());
         }
       }
-
+      // XMP buffer
+      if ((baton->keepMetadata & VIPS_FOREIGN_KEEP_XMP) && !baton->withXmp.empty()) {
+        image = image.copy();
+        image.set(VIPS_META_XMP_NAME, nullptr,
+          const_cast<void*>(static_cast<void const*>(baton->withXmp.c_str())), baton->withXmp.size());
+      }
       // Number of channels used in output image
       baton->channels = image.bands();
       baton->width = image.width();
@@ -1002,6 +986,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("interlace", baton->gifProgressive)
             ->set("interframe_maxerror", baton->gifInterFrameMaxError)
             ->set("interpalette_maxerror", baton->gifInterPaletteMaxError)
+            ->set("keep_duplicate_frames", baton->gifKeepDuplicateFrames)
             ->set("dither", baton->gifDither)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
@@ -1205,6 +1190,9 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("effort", baton->gifEffort)
             ->set("reuse", baton->gifReuse)
             ->set("interlace", baton->gifProgressive)
+            ->set("interframe_maxerror", baton->gifInterFrameMaxError)
+            ->set("interpalette_maxerror", baton->gifInterPaletteMaxError)
+            ->set("keep_duplicate_frames", baton->gifKeepDuplicateFrames)
             ->set("dither", baton->gifDither));
           baton->formatOut = "gif";
         } else if (baton->formatOut == "tiff" || (mightMatchInput && isTiff) ||
@@ -1359,7 +1347,8 @@ class PipelineWorker : public Napi::AsyncWorker {
         // Add file size to info
         if (baton->formatOut != "dz" || sharp::IsDzZip(baton->fileOut)) {
           try {
-            uint32_t const size = static_cast<uint32_t>(std::filesystem::file_size(baton->fileOut));
+            uint32_t const size = static_cast<uint32_t>(
+              std::filesystem::file_size(std::filesystem::u8path(baton->fileOut)));
             info.Set("size", size);
           } catch (...) {}
         }
@@ -1405,21 +1394,20 @@ class PipelineWorker : public Napi::AsyncWorker {
     Calculate the angle of rotation and need-to-flip for the given Exif orientation
     By default, returns zero, i.e. no rotation.
   */
-  std::tuple<VipsAngle, bool, bool>
-  CalculateExifRotationAndFlip(int const exifOrientation) {
+  std::tuple<VipsAngle, bool>
+  CalculateExifRotationAndFlop(int const exifOrientation) {
     VipsAngle rotate = VIPS_ANGLE_D0;
-    bool flip = false;
     bool flop = false;
     switch (exifOrientation) {
       case 6: rotate = VIPS_ANGLE_D90; break;
       case 3: rotate = VIPS_ANGLE_D180; break;
       case 8: rotate = VIPS_ANGLE_D270; break;
-      case 2: flop = true; break;  // flop 1
-      case 7: flip = true; rotate = VIPS_ANGLE_D90; break;  // flip 6
-      case 4: flop = true; rotate = VIPS_ANGLE_D180; break;  // flop 3
-      case 5: flip = true; rotate = VIPS_ANGLE_D270; break;  // flip 8
+      case 2: flop = true; break;
+      case 7: flop = true; rotate = VIPS_ANGLE_D270; break;
+      case 4: flop = true; rotate = VIPS_ANGLE_D180; break;
+      case 5: flop = true; rotate = VIPS_ANGLE_D90; break;
     }
-    return std::make_tuple(rotate, flip, flop);
+    return std::make_tuple(rotate, flop);
   }
 
   /*
@@ -1644,7 +1632,8 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->angle = sharp::AttrAsInt32(options, "angle");
   baton->rotationAngle = sharp::AttrAsDouble(options, "rotationAngle");
   baton->rotationBackground = sharp::AttrAsVectorOfDouble(options, "rotationBackground");
-  baton->rotateBeforePreExtract = sharp::AttrAsBool(options, "rotateBeforePreExtract");
+  baton->rotateBefore = sharp::AttrAsBool(options, "rotateBefore");
+  baton->orientBefore = sharp::AttrAsBool(options, "orientBefore");
   baton->flip = sharp::AttrAsBool(options, "flip");
   baton->flop = sharp::AttrAsBool(options, "flop");
   baton->extendTop = sharp::AttrAsInt32(options, "extendTop");
@@ -1716,6 +1705,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     }
   }
   baton->withExifMerge = sharp::AttrAsBool(options, "withExifMerge");
+  baton->withXmp = sharp::AttrAsStr(options, "withXmp");
   baton->timeoutSeconds = sharp::AttrAsUint32(options, "timeoutSeconds");
   baton->loop = sharp::AttrAsUint32(options, "loop");
   baton->delay = sharp::AttrAsInt32Vector(options, "delay");
@@ -1756,6 +1746,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->gifDither = sharp::AttrAsDouble(options, "gifDither");
   baton->gifInterFrameMaxError = sharp::AttrAsDouble(options, "gifInterFrameMaxError");
   baton->gifInterPaletteMaxError = sharp::AttrAsDouble(options, "gifInterPaletteMaxError");
+  baton->gifKeepDuplicateFrames = sharp::AttrAsBool(options, "gifKeepDuplicateFrames");
   baton->gifReuse = sharp::AttrAsBool(options, "gifReuse");
   baton->gifProgressive = sharp::AttrAsBool(options, "gifProgressive");
   baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");

package/src/pipeline.h

@@ -115,7 +115,8 @@ struct PipelineBaton {
   int angle;
   double rotationAngle;
   std::vector<double> rotationBackground;
-  bool rotateBeforePreExtract;
+  bool rotateBefore;
+  bool orientBefore;
   bool flip;
   bool flop;
   int extendTop;
@@ -169,6 +170,7 @@ struct PipelineBaton {
   double gifDither;
   double gifInterFrameMaxError;
   double gifInterPaletteMaxError;
+  bool gifKeepDuplicateFrames;
   bool gifReuse;
   bool gifProgressive;
   int tiffQuality;
@@ -201,6 +203,7 @@ struct PipelineBaton {
   std::string withIccProfile;
   std::unordered_map<std::string, std::string> withExif;
   bool withExifMerge;
+  std::string withXmp;
   int timeoutSeconds;
   std::vector<double> convKernel;
   int convKernelWidth;
@@ -342,6 +345,7 @@ struct PipelineBaton {
     gifDither(1.0),
     gifInterFrameMaxError(0.0),
     gifInterPaletteMaxError(3.0),
+    gifKeepDuplicateFrames(false),
     gifReuse(true),
     gifProgressive(false),
     tiffQuality(80),

package/src/stats.cc

@@ -60,7 +60,7 @@ class StatsWorker : public Napi::AsyncWorker {
         // Image is not opaque when alpha layer is present and contains a non-mamixa value
         if (image.has_alpha()) {
           double const minAlpha = static_cast<double>(stats.getpoint(STAT_MIN_INDEX, bands).front());
-          if (minAlpha != sharp::MaximumImageAlpha(image.interpretation())) {
+          if (minAlpha != vips_interpretation_max_alpha(image.interpretation())) {
             baton->isOpaque = false;
           }
         }

package/src/utilities.cc

@@ -119,7 +119,7 @@ Napi::Value format(const Napi::CallbackInfo& info) {
   Napi::Object format = Napi::Object::New(env);
   for (std::string const f : {
     "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz",
-    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl", "rad"
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k", "jxl", "rad", "dcraw"
   }) {
     // Input
     const VipsObjectClass *oc = vips_class_find("VipsOperation", (f + "load").c_str());