@revizly/sharp 0.35.0-revizly4 → 0.35.0-revizly41

package/src/common.cc

@@ -196,8 +196,8 @@ namespace sharp {
     if (HasAttr(input, "joinValign")) {
       descriptor->joinValign = AttrAsEnum<VipsAlign>(input, "joinValign", VIPS_TYPE_ALIGN);
     }
-    // Limit input images to a given number of pixels, where pixels = width * height
     descriptor->limitInputPixels = static_cast<uint64_t>(AttrAsInt64(input, "limitInputPixels"));
+    descriptor->limitInputChannels = static_cast<uint64_t>(AttrAsInt64(input, "limitInputChannels"));
     if (HasAttr(input, "access")) {
       descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
     }
@@ -289,6 +289,7 @@ namespace sharp {
       case ImageType::JXL: id = "jxl"; break;
       case ImageType::RAD: id = "rad"; break;
       case ImageType::DCRAW: id = "dcraw"; break;
+      case ImageType::UHDR: id = "uhdr"; break;
       case ImageType::VIPS: id = "vips"; break;
       case ImageType::RAW: id = "raw"; break;
       case ImageType::UNKNOWN: id = "unknown"; break;
@@ -339,6 +340,9 @@ namespace sharp {
     { "VipsForeignLoadRadBuffer", ImageType::RAD },
     { "VipsForeignLoadDcRawFile", ImageType::DCRAW },
     { "VipsForeignLoadDcRawBuffer", ImageType::DCRAW },
+    { "VipsForeignLoadUhdr", ImageType::UHDR },
+    { "VipsForeignLoadUhdrFile", ImageType::UHDR },
+    { "VipsForeignLoadUhdrBuffer", ImageType::UHDR },
     { "VipsForeignLoadVips", ImageType::VIPS },
     { "VipsForeignLoadVipsFile", ImageType::VIPS },
     { "VipsForeignLoadRaw", ImageType::RAW }
@@ -356,6 +360,9 @@ namespace sharp {
         imageType = it->second;
       }
     }
+    if (imageType == ImageType::UHDR) {
+      imageType = ImageType::JPEG;
+    }
     return imageType;
   }
 
@@ -375,6 +382,9 @@ namespace sharp {
         imageType = ImageType::MISSING;
       }
     }
+    if (imageType == ImageType::UHDR) {
+      imageType = ImageType::JPEG;
+    }
     return imageType;
   }
 
@@ -416,7 +426,7 @@ namespace sharp {
     }
     if (ImageTypeSupportsPage(imageType)) {
       option->set("n", descriptor->pages);
-      option->set("page", descriptor->page);
+      option->set("page", std::max(0, descriptor->page));
     }
     switch (imageType) {
       case ImageType::SVG:
@@ -446,6 +456,22 @@ namespace sharp {
     return option;
   }
 
+  /*
+    Should HEIF image be re-opened using the primary item?
+  */
+  static bool HeifPrimaryPageReopen(VImage image, InputDescriptor *descriptor) {
+    if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT && image.get_typeof("heif-primary") == G_TYPE_INT) {
+      if (image.get_int(VIPS_META_N_PAGES) > 1 && descriptor->pages == 1 && descriptor->page == -1) {
+        int const pagePrimary = image.get_int("heif-primary");
+        if (pagePrimary != 0) {
+          descriptor->page = pagePrimary;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   /*
     Open an image from the given InputDescriptor (filesystem, compressed buffer, raw pixel data)
   */
@@ -480,12 +506,15 @@ namespace sharp {
             image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
+            } else if (imageType == ImageType::HEIF && HeifPrimaryPageReopen(image, descriptor)) {
+              option = GetOptionsForImageType(imageType, descriptor);
+              image = VImage::new_from_buffer(descriptor->buffer, descriptor->bufferLength, nullptr, option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input buffer has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input buffer has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input buffer contains unsupported image format");
+          throw std::runtime_error("Input buffer contains unsupported image format");
         }
       }
     } else {
@@ -556,10 +585,10 @@ namespace sharp {
         imageType = DetermineImageType(descriptor->file.data());
         if (imageType == ImageType::MISSING) {
           if (descriptor->file.find("<svg") != std::string::npos) {
-            throw vips::VError("Input file is missing, did you mean "
+            throw std::runtime_error("Input file is missing, did you mean "
               "sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");
           }
-          throw vips::VError("Input file is missing: " + descriptor->file);
+          throw std::runtime_error("Input file is missing: " + descriptor->file);
         }
         if (imageType != ImageType::UNKNOWN) {
           try {
@@ -567,12 +596,15 @@ namespace sharp {
             image = VImage::new_from_file(descriptor->file.data(), option);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF || imageType == ImageType::MAGICK) {
               image = SetDensity(image, descriptor->density);
+            } else if (imageType == ImageType::HEIF && HeifPrimaryPageReopen(image, descriptor)) {
+              option = GetOptionsForImageType(imageType, descriptor);
+              image = VImage::new_from_file(descriptor->file.data(), option);
             }
-          } catch (vips::VError const &err) {
-            throw vips::VError(std::string("Input file has corrupt header: ") + err.what());
+          } catch (std::runtime_error const &err) {
+            throw std::runtime_error(std::string("Input file has corrupt header: ") + err.what());
           }
         } else {
-          throw vips::VError("Input file contains unsupported image format");
+          throw std::runtime_error("Input file contains unsupported image format");
         }
       }
     }
@@ -580,7 +612,10 @@ namespace sharp {
     // Limit input images to a given number of pixels, where pixels = width * height
     if (descriptor->limitInputPixels > 0 &&
       static_cast<uint64_t>(image.width()) * image.height() > descriptor->limitInputPixels) {
-      throw vips::VError("Input image exceeds pixel limit");
+      throw std::runtime_error("Input image exceeds pixel limit");
+    }
+    if (descriptor->limitInputChannels > 0 && static_cast<uint64_t>(image.bands()) > descriptor->limitInputChannels) {
+      throw std::runtime_error("Input image exceeds channel limit");
     }
     return std::make_tuple(image, imageType);
   }
@@ -600,7 +635,7 @@ namespace sharp {
     if (HasProfile(image)) {
       size_t length;
       const void *data = image.get_blob(VIPS_META_ICC_NAME, &length);
-      icc.first = static_cast<char*>(g_malloc(length));
+      icc.first = static_cast<char*>(vips_malloc(reinterpret_cast<VipsObject*>(image.get_image()), length));
       icc.second = length;
       memcpy(icc.first, data, length);
     }
@@ -613,7 +648,7 @@ namespace sharp {
   VImage SetProfile(VImage image, std::pair<char*, size_t> icc) {
     if (icc.first != nullptr) {
       image = image.copy();
-      image.set(VIPS_META_ICC_NAME, reinterpret_cast<VipsCallbackFn>(vips_area_free_cb), icc.first, icc.second);
+      image.set(VIPS_META_ICC_NAME, nullptr, icc.first, icc.second);
     }
     return image;
   }
@@ -756,19 +791,19 @@ namespace sharp {
       : image.height();
     if (imageType == ImageType::JPEG) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the JPEG format");
+        throw std::runtime_error("Processed image is too large for the JPEG format");
       }
     } else if (imageType == ImageType::WEBP) {
       if (image.width() > 16383 || height > 16383) {
-        throw vips::VError("Processed image is too large for the WebP format");
+        throw std::runtime_error("Processed image is too large for the WebP format");
       }
     } else if (imageType == ImageType::GIF) {
       if (image.width() > 65535 || height > 65535) {
-        throw vips::VError("Processed image is too large for the GIF format");
+        throw std::runtime_error("Processed image is too large for the GIF format");
       }
     } else if (imageType == ImageType::HEIF) {
       if (image.width() > 16384 || height > 16384) {
-        throw vips::VError("Processed image is too large for the HEIF format");
+        throw std::runtime_error("Processed image is too large for the HEIF format");
       }
     }
   }
@@ -1127,4 +1162,22 @@ namespace sharp {
     }
     return image;
   }
+
+  /*
+    Does this image have a gain map?
+  */
+  bool HasGainMap(VImage image) {
+    return image.get_typeof("gainmap") == VIPS_TYPE_BLOB ||
+      image.get_typeof("gainmap-data") == VIPS_TYPE_BLOB;
+  }
+
+  /*
+    Removes gain map, if any.
+  */
+  VImage RemoveGainMap(VImage image) {
+    VImage copy = image.copy();
+    copy.remove("gainmap");
+    copy.remove("gainmap-data");
+    return copy;
+  }
 }  // namespace sharp

package/src/common.h

@@ -19,8 +19,8 @@
 
 #if (VIPS_MAJOR_VERSION < 8) || \
   (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 18) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 18 && VIPS_MICRO_VERSION < 0)
-#error "libvips version 8.18.0+ is required - please see https://sharp.pixelplumbing.com/install"
+  (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(__has_include)
@@ -29,6 +29,12 @@
 #endif
 #endif
 
+#ifdef __EMSCRIPTEN__
+#define SHARP_CALLBACK_FN_NAME Call
+#else
+#define SHARP_CALLBACK_FN_NAME MakeCallback
+#endif
+
 using vips::VImage;
 
 namespace sharp {
@@ -40,6 +46,7 @@ namespace sharp {
     char *buffer;
     VipsFailOn failOn;
     uint64_t limitInputPixels;
+    uint64_t limitInputChannels;
     bool unlimited;
     VipsAccess access;
     size_t bufferLength;
@@ -92,6 +99,7 @@ namespace sharp {
       buffer(nullptr),
       failOn(VIPS_FAIL_ON_WARNING),
       limitInputPixels(0x3FFF * 0x3FFF),
+      limitInputChannels(5),
       unlimited(false),
       access(VIPS_ACCESS_SEQUENTIAL),
       bufferLength(0),
@@ -105,7 +113,7 @@ namespace sharp {
       rawPremultiplied(false),
       rawPageHeight(0),
       pages(1),
-      page(0),
+      page(-1),
       createChannels(0),
       createWidth(0),
       createHeight(0),
@@ -173,6 +181,7 @@ namespace sharp {
     JXL,
     RAD,
     DCRAW,
+    UHDR,
     VIPS,
     RAW,
     UNKNOWN,
@@ -397,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

@@ -31,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) {
@@ -141,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
@@ -157,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);
       }
@@ -182,10 +237,6 @@ class MetadataWorker : public Napi::AsyncWorker {
       info.Set("isPalette", baton->isPalette);
       if (baton->bitsPerSample > 0) {
         info.Set("bitsPerSample", baton->bitsPerSample);
-        if (baton->isPalette) {
-          // Deprecated, remove with libvips 8.17.0
-          info.Set("paletteBitDepth", baton->bitsPerSample);
-        }
       }
       if (baton->pages > 0) {
         info.Set("pages", baton->pages);
@@ -276,6 +327,12 @@ 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());
@@ -287,9 +344,10 @@ class MetadataWorker : public Napi::AsyncWorker {
         }
         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

@@ -19,6 +19,7 @@ struct MetadataBaton {
   sharp::InputDescriptor *input;
   // Output
   std::string format;
+  std::string mediaType;
   int width;
   int height;
   std::string space;
@@ -53,6 +54,8 @@ struct MetadataBaton {
   size_t xmpLength;
   char *tifftagPhotoshop;
   size_t tifftagPhotoshopLength;
+  char *gainMap;
+  size_t gainMapLength;
   MetadataComments comments;
   std::string err;
 
@@ -82,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);

package/src/operations.cc

@@ -14,7 +14,6 @@
 #include "./operations.h"
 
 using vips::VImage;
-using vips::VError;
 
 namespace sharp {
   /*
@@ -285,9 +284,9 @@ namespace sharp {
   /*
     Trim an image
   */
-  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt) {
+  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt, int const margin) {
     if (image.width() < 3 && image.height() < 3) {
-      throw VError("Image to trim must be at least 3x3 pixels");
+      throw std::runtime_error("Image to trim must be at least 3x3 pixels");
     }
     if (background.size() == 0) {
       // Top-left pixel provides the default background colour if none is given
@@ -320,18 +319,36 @@ namespace sharp {
       if (widthA > 0 && heightA > 0) {
         if (width > 0 && height > 0) {
           // Combined bounding box (B)
-          int const leftB = std::min(left, leftA);
-          int const topB = std::min(top, topA);
-          int const widthB = std::max(left + width, leftA + widthA) - leftB;
-          int const heightB = std::max(top + height, topA + heightA) - topB;
+          int leftB = std::min(left, leftA);
+          int topB = std::min(top, topA);
+          int widthB = std::max(left + width, leftA + widthA) - leftB;
+          int heightB = std::max(top + height, topA + heightA) - topB;
+          if (margin > 0) {
+            leftB = std::max(0, leftB - margin);
+            topB = std::max(0, topB - margin);
+            widthB = std::min(image.width() - leftB, widthB + 2 * margin);
+            heightB = std::min(image.height() - topB, heightB + 2 * margin);
+          }
           return image.extract_area(leftB, topB, widthB, heightB);
         } else {
           // Use alpha only
+          if (margin > 0) {
+            leftA = std::max(0, leftA - margin);
+            topA = std::max(0, topA - margin);
+            widthA = std::min(image.width() - leftA, widthA + 2 * margin);
+            heightA = std::min(image.height() - topA, heightA + 2 * margin);
+          }
           return image.extract_area(leftA, topA, widthA, heightA);
         }
       }
     }
     if (width > 0 && height > 0) {
+      if (margin > 0) {
+        left = std::max(0, left - margin);
+        top = std::max(0, top - margin);
+        width = std::min(image.width() - left, width + 2 * margin);
+        height = std::min(image.height() - top, height + 2 * margin);
+      }
       return image.extract_area(left, top, width, height);
     }
     return image;
@@ -343,7 +360,7 @@ namespace sharp {
   VImage Linear(VImage image, std::vector<double> const a, std::vector<double> const b) {
     size_t const bands = static_cast<size_t>(image.bands());
     if (a.size() > bands) {
-      throw VError("Band expansion using linear is unsupported");
+      throw std::runtime_error("Band expansion using linear is unsupported");
     }
     bool const uchar = !Is16Bit(image.interpretation());
     if (image.has_alpha() && a.size() != bands && (a.size() == 1 || a.size() == bands - 1 || bands - 1 == 1)) {

package/src/operations.h

@@ -82,7 +82,7 @@ namespace sharp {
   /*
     Trim an image
   */
-  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt);
+  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt, int const margin);
 
   /*
    * Linear adjustment (a * in + b)