sharp 0.33.5 → 0.35.3

package/src/common.h

@@ -1,13 +1,16 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
 #ifndef SRC_COMMON_H_
 #define SRC_COMMON_H_
 
+#include <atomic>
 #include <string>
 #include <tuple>
+#include <utility>
 #include <vector>
-#include <atomic>
 
 #include <napi.h>
 #include <vips/vips8>
@@ -15,31 +18,35 @@
 // Verify platform and compiler compatibility
 
 #if (VIPS_MAJOR_VERSION < 8) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 15) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 15 && VIPS_MICRO_VERSION < 3)
-#error "libvips version 8.15.3+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 18) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 18 && VIPS_MICRO_VERSION < 3)
+#error "libvips version 8.18.3+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
-#if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
-#error "GCC version 4.6+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
+#if defined(__has_include)
+#if !__has_include(<filesystem>)
+#error "C++17 compiler required - please see https://sharp.pixelplumbing.com/install"
 #endif
-
-#if (defined(__clang__) && defined(__has_feature))
-#if (!__has_feature(cxx_range_for))
-#error "clang version 3.0+ is required for C++11 features - please see https://sharp.pixelplumbing.com/install"
 #endif
+
+#ifdef __EMSCRIPTEN__
+#define SHARP_CALLBACK_FN_NAME Call
+#else
+#define SHARP_CALLBACK_FN_NAME MakeCallback
 #endif
 
 using vips::VImage;
 
 namespace sharp {
 
-  struct InputDescriptor {  // NOLINT(runtime/indentation_namespace)
+  struct InputDescriptor {
     std::string name;
     std::string file;
+    bool autoOrient;
     char *buffer;
     VipsFailOn failOn;
     uint64_t limitInputPixels;
+    uint64_t limitInputChannels;
     bool unlimited;
     VipsAccess access;
     size_t bufferLength;
@@ -51,13 +58,13 @@ namespace sharp {
     int rawWidth;
     int rawHeight;
     bool rawPremultiplied;
+    int rawPageHeight;
     int pages;
     int page;
-    int level;
-    int subifd;
     int createChannels;
     int createWidth;
     int createHeight;
+    int createPageHeight;
     std::vector<double> createBackground;
     std::string createNoiseType;
     double createNoiseMean;
@@ -74,13 +81,27 @@ namespace sharp {
     int textSpacing;
     VipsTextWrap textWrap;
     int textAutofitDpi;
+    bool joinAnimated;
+    int joinAcross;
+    int joinShim;
+    std::vector<double> joinBackground;
+    VipsAlign joinHalign;
+    VipsAlign joinValign;
+    std::string svgStylesheet;
+    bool svgHighBitdepth;
+    int tiffSubifd;
+    int openSlideLevel;
+    std::vector<double> pdfBackground;
+    bool jp2Oneshot;
 
     InputDescriptor():
+      autoOrient(false),
       buffer(nullptr),
       failOn(VIPS_FAIL_ON_WARNING),
       limitInputPixels(0x3FFF * 0x3FFF),
+      limitInputChannels(5),
       unlimited(false),
-      access(VIPS_ACCESS_RANDOM),
+      access(VIPS_ACCESS_SEQUENTIAL),
       bufferLength(0),
       isBuffer(false),
       density(72.0),
@@ -90,13 +111,13 @@ namespace sharp {
       rawWidth(0),
       rawHeight(0),
       rawPremultiplied(false),
+      rawPageHeight(0),
       pages(1),
-      page(0),
-      level(0),
-      subifd(-1),
+      page(-1),
       createChannels(0),
       createWidth(0),
       createHeight(0),
+      createPageHeight(0),
       createBackground{ 0.0, 0.0, 0.0, 255.0 },
       createNoiseMean(0.0),
       createNoiseSigma(0.0),
@@ -108,7 +129,18 @@ namespace sharp {
       textRgba(false),
       textSpacing(0),
       textWrap(VIPS_TEXT_WRAP_WORD),
-      textAutofitDpi(0) {}
+      textAutofitDpi(0),
+      joinAnimated(false),
+      joinAcross(1),
+      joinShim(0),
+      joinBackground{ 0.0, 0.0, 0.0, 255.0 },
+      joinHalign(VIPS_ALIGN_LOW),
+      joinValign(VIPS_ALIGN_LOW),
+      svgHighBitdepth(false),
+      tiffSubifd(-1),
+      openSlideLevel(0),
+      pdfBackground{ 255.0, 255.0, 255.0, 255.0 },
+      jp2Oneshot(false) {}
   };
 
   // Convenience methods to access the attributes of a Napi::Object
@@ -147,6 +179,9 @@ namespace sharp {
     FITS,
     EXR,
     JXL,
+    RAD,
+    DCRAW,
+    UHDR,
     VIPS,
     RAW,
     UNKNOWN,
@@ -203,14 +238,9 @@ namespace sharp {
   ImageType DetermineImageType(char const *file);
 
   /*
-    Does this image type support multiple pages?
-  */
-  bool ImageTypeSupportsPage(ImageType imageType);
-
-  /*
-    Does this image type support removal of safety limits?
+    Format-specific options builder
   */
-  bool ImageTypeSupportsUnlimited(ImageType imageType);
+  vips::VOption* GetOptionsForImageType(ImageType imageType, InputDescriptor *descriptor);
 
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
@@ -232,12 +262,6 @@ namespace sharp {
   */
   VImage SetProfile(VImage image, std::pair<char*, size_t> icc);
 
-  /*
-    Does this image have an alpha channel?
-    Uses colour space interpretation with number of channels to guess this.
-  */
-  bool HasAlpha(VImage image);
-
   /*
     Remove all EXIF-related image fields.
   */
@@ -350,12 +374,6 @@ namespace sharp {
   */
   bool Is16Bit(VipsInterpretation const interpretation);
 
-  /*
-    Return the image alpha maximum. Useful for combining alpha bands. scRGB
-    images are 0 - 1 for image data, but the alpha is 0 - 255.
-  */
-  double MaximumImageAlpha(VipsInterpretation const interpretation);
-
   /*
     Convert RGBA value to another colourspace
   */
@@ -368,7 +386,7 @@ namespace sharp {
   std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour, bool premultiply);
 
   /*
-    Removes alpha channel, if any.
+    Removes alpha channels, if any.
   */
   VImage RemoveAlpha(VImage image);
 
@@ -388,6 +406,16 @@ namespace sharp {
   */
   VImage StaySequential(VImage image, bool condition = true);
 
+  /*
+    Does this image have a gain map?
+  */
+  bool HasGainMap(VImage image);
+
+  /*
+    Removes gain map, if any.
+  */
+  VImage RemoveGainMap(VImage image);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_

package/src/metadata.cc

@@ -1,14 +1,19 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
+#include <cmath>
 #include <numeric>
+#include <string>
+#include <utility>
 #include <vector>
 
 #include <napi.h>
 #include <vips/vips8>
 
-#include "common.h"
-#include "metadata.h"
+#include "./common.h"
+#include "./metadata.h"
 
 static void* readPNGComment(VipsImage *image, const char *field, GValue *value, void *p);
 
@@ -26,7 +31,7 @@ class MetadataWorker : public Napi::AsyncWorker {
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
     try {
       std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
+    } catch (std::runtime_error const &err) {
       (baton->err).append(err.what());
     }
     if (imageType != sharp::ImageType::UNKNOWN) {
@@ -47,8 +52,11 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (image.get_typeof("interlaced") == G_TYPE_INT) {
         baton->isProgressive = image.get_int("interlaced") == 1;
       }
-      if (image.get_typeof("palette-bit-depth") == G_TYPE_INT) {
-        baton->paletteBitDepth = image.get_int("palette-bit-depth");
+      if (image.get_typeof(VIPS_META_PALETTE) == G_TYPE_INT) {
+        baton->isPalette = image.get_int(VIPS_META_PALETTE);
+      }
+      if (image.get_typeof(VIPS_META_BITS_PER_SAMPLE) == G_TYPE_INT) {
+        baton->bitsPerSample = image.get_int(VIPS_META_BITS_PER_SAMPLE);
       }
       if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT) {
         baton->pages = image.get_int(VIPS_META_N_PAGES);
@@ -91,7 +99,7 @@ class MetadataWorker : public Napi::AsyncWorker {
         baton->background = image.get_array_double("background");
       }
       // Derived attributes
-      baton->hasAlpha = sharp::HasAlpha(image);
+      baton->hasAlpha = image.has_alpha();
       baton->orientation = sharp::ExifOrientation(image);
       // EXIF
       if (image.get_typeof(VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
@@ -133,8 +141,60 @@ class MetadataWorker : public Napi::AsyncWorker {
         memcpy(baton->tifftagPhotoshop, tifftagPhotoshop, tifftagPhotoshopLength);
         baton->tifftagPhotoshopLength = tifftagPhotoshopLength;
       }
+      // Gain Map
+      if (image.get_typeof("gainmap-data") == VIPS_TYPE_BLOB) {
+        size_t gainMapLength;
+        void const *gainMap = image.get_blob("gainmap-data", &gainMapLength);
+        baton->gainMap = static_cast<char *>(g_malloc(gainMapLength));
+        memcpy(baton->gainMap, gainMap, gainMapLength);
+        baton->gainMapLength = gainMapLength;
+      }
       // PNG comments
       vips_image_map(image.get_image(), readPNGComment, &baton->comments);
+      // Media type
+      std::string mediaType;
+      switch (imageType) {
+        case sharp::ImageType::JPEG:
+        case sharp::ImageType::PNG:
+        case sharp::ImageType::WEBP:
+        case sharp::ImageType::JP2:
+        case sharp::ImageType::TIFF:
+        case sharp::ImageType::GIF:
+        case sharp::ImageType::FITS:
+        case sharp::ImageType::JXL:
+          baton->mediaType = "image/" + baton->format;
+          break;
+        case sharp::ImageType::SVG:
+          baton->mediaType = "image/svg+xml";
+          break;
+        case sharp::ImageType::HEIF:
+          if (baton->compression == "av1") {
+            baton->mediaType = "image/avif";
+          } else if (baton->compression == "hevc") {
+            baton->mediaType = "image/heic";
+          }
+          break;
+        case sharp::ImageType::PDF:
+          baton->mediaType = "application/pdf";
+          break;
+        case sharp::ImageType::OPENSLIDE:
+          baton->mediaType = "image/tiff";
+          break;
+        case sharp::ImageType::PPM:
+          baton->mediaType = "image/x-portable-pixmap";
+          break;
+        case sharp::ImageType::EXR:
+          baton->mediaType = "image/x-exr";
+          break;
+        case sharp::ImageType::RAD:
+          baton->mediaType = "image/vnd.radiance";
+          break;
+        case sharp::ImageType::UHDR:
+          baton->mediaType = "image/jpeg";
+          break;
+        default:
+          break;
+      }
     }
 
     // Clean up
@@ -149,13 +209,16 @@ class MetadataWorker : public Napi::AsyncWorker {
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
+      debuglog.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
     if (baton->err.empty()) {
       Napi::Object info = Napi::Object::New(env);
       info.Set("format", baton->format);
+      if (!baton->mediaType.empty()) {
+        info.Set("mediaType", baton->mediaType);
+      }
       if (baton->input->bufferLength > 0) {
         info.Set("size", baton->input->bufferLength);
       }
@@ -171,8 +234,9 @@ class MetadataWorker : public Napi::AsyncWorker {
         info.Set("chromaSubsampling", baton->chromaSubsampling);
       }
       info.Set("isProgressive", baton->isProgressive);
-      if (baton->paletteBitDepth > 0) {
-        info.Set("paletteBitDepth", baton->paletteBitDepth);
+      info.Set("isPalette", baton->isPalette);
+      if (baton->bitsPerSample > 0) {
+        info.Set("bitsPerSample", baton->bitsPerSample);
       }
       if (baton->pages > 0) {
         info.Set("pages", baton->pages);
@@ -206,10 +270,10 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (!baton->levels.empty()) {
         int i = 0;
         Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));
-        for (std::pair<int, int> const &l : baton->levels) {
+        for (const auto& [width, height] : baton->levels) {
           Napi::Object level = Napi::Object::New(env);
-          level.Set("width", l.first);
-          level.Set("height", l.second);
+          level.Set("width", width);
+          level.Set("height", height);
           levels.Set(i++, level);
         }
         info.Set("levels", levels);
@@ -218,21 +282,30 @@ class MetadataWorker : public Napi::AsyncWorker {
         info.Set("subifds", baton->subifds);
       }
       if (!baton->background.empty()) {
+        Napi::Object background = Napi::Object::New(env);
         if (baton->background.size() == 3) {
-          Napi::Object background = Napi::Object::New(env);
           background.Set("r", baton->background[0]);
           background.Set("g", baton->background[1]);
           background.Set("b", baton->background[2]);
-          info.Set("background", background);
         } else {
-          info.Set("background", baton->background[0]);
+          background.Set("gray", round(baton->background[0] * 100 / 255));
         }
+        info.Set("background", background);
       }
       info.Set("hasProfile", baton->hasProfile);
       info.Set("hasAlpha", baton->hasAlpha);
       if (baton->orientation > 0) {
         info.Set("orientation", baton->orientation);
       }
+      Napi::Object autoOrient = Napi::Object::New(env);
+      info.Set("autoOrient", autoOrient);
+      if (baton->orientation >= 5) {
+        autoOrient.Set("width", baton->height);
+        autoOrient.Set("height", baton->width);
+      } else {
+        autoOrient.Set("width", baton->width);
+        autoOrient.Set("height", baton->height);
+      }
       if (baton->exifLength > 0) {
         info.Set("exif", Napi::Buffer<char>::NewOrCopy(env, baton->exif, baton->exifLength, sharp::FreeCallback));
       }
@@ -243,6 +316,10 @@ class MetadataWorker : public Napi::AsyncWorker {
         info.Set("iptc", Napi::Buffer<char>::NewOrCopy(env, baton->iptc, baton->iptcLength, sharp::FreeCallback));
       }
       if (baton->xmpLength > 0) {
+        if (g_utf8_validate(static_cast<char const *>(baton->xmp), baton->xmpLength, nullptr)) {
+          info.Set("xmpAsString",
+            Napi::String::New(env, static_cast<char const *>(baton->xmp), baton->xmpLength));
+        }
         info.Set("xmp", Napi::Buffer<char>::NewOrCopy(env, baton->xmp, baton->xmpLength, sharp::FreeCallback));
       }
       if (baton->tifftagPhotoshopLength > 0) {
@@ -250,20 +327,27 @@ class MetadataWorker : public Napi::AsyncWorker {
           Napi::Buffer<char>::NewOrCopy(env, baton->tifftagPhotoshop,
             baton->tifftagPhotoshopLength, sharp::FreeCallback));
       }
+      if (baton->gainMapLength > 0) {
+        Napi::Object gainMap = Napi::Object::New(env);
+        info.Set("gainMap", gainMap);
+        gainMap.Set("image",
+          Napi::Buffer<char>::NewOrCopy(env, baton->gainMap, baton->gainMapLength, sharp::FreeCallback));
+      }
       if (baton->comments.size() > 0) {
         int i = 0;
         Napi::Array comments = Napi::Array::New(env, baton->comments.size());
-        for (auto &c : baton->comments) {
+        for (const auto& [keyword, text] : baton->comments) {
           Napi::Object comment = Napi::Object::New(env);
-          comment.Set("keyword", c.first);
-          comment.Set("text", c.second);
+          comment.Set("keyword", keyword);
+          comment.Set("text", text);
           comments.Set(i++, comment);
         }
         info.Set("comments", comments);
       }
-      Callback().Call(Receiver().Value(), { env.Null(), info });
+      Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), info });
     } else {
-      Callback().Call(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
+      Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(),
+        { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
     }
 
     delete baton->input;

package/src/metadata.h

@@ -1,10 +1,13 @@
-// Copyright 2013 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
+/*!
+  Copyright 2013 Lovell Fuller and others.
+  SPDX-License-Identifier: Apache-2.0
+*/
 
 #ifndef SRC_METADATA_H_
 #define SRC_METADATA_H_
 
 #include <string>
+#include <vector>
 #include <napi.h>
 
 #include "./common.h"
@@ -16,6 +19,7 @@ struct MetadataBaton {
   sharp::InputDescriptor *input;
   // Output
   std::string format;
+  std::string mediaType;
   int width;
   int height;
   std::string space;
@@ -24,7 +28,8 @@ struct MetadataBaton {
   int density;
   std::string chromaSubsampling;
   bool isProgressive;
-  int paletteBitDepth;
+  bool isPalette;
+  int bitsPerSample;
   int pages;
   int pageHeight;
   int loop;
@@ -49,6 +54,8 @@ struct MetadataBaton {
   size_t xmpLength;
   char *tifftagPhotoshop;
   size_t tifftagPhotoshopLength;
+  char *gainMap;
+  size_t gainMapLength;
   MetadataComments comments;
   std::string err;
 
@@ -59,7 +66,8 @@ struct MetadataBaton {
     channels(0),
     density(0),
     isProgressive(false),
-    paletteBitDepth(0),
+    isPalette(false),
+    bitsPerSample(0),
     pages(0),
     pageHeight(0),
     loop(-1),
@@ -77,7 +85,9 @@ struct MetadataBaton {
     xmp(nullptr),
     xmpLength(0),
     tifftagPhotoshop(nullptr),
-    tifftagPhotoshopLength(0) {}
+    tifftagPhotoshopLength(0),
+    gainMap(nullptr),
+    gainMapLength(0) {}
 };
 
 Napi::Value metadata(const Napi::CallbackInfo& info);