sharp 0.29.3 → 0.30.2

package/src/common.cc

@@ -132,6 +132,8 @@ namespace sharp {
     descriptor->limitInputPixels = AttrAsUint32(input, "limitInputPixels");
     // Allow switch from random to sequential access
     descriptor->access = AttrAsBool(input, "sequentialRead") ? VIPS_ACCESS_SEQUENTIAL : VIPS_ACCESS_RANDOM;
+    // Remove safety features and allow unlimited SVG/PNG input
+    descriptor->unlimited = AttrAsBool(input, "unlimited");
     return descriptor;
   }
 
@@ -328,7 +330,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
-            if (imageType == ImageType::SVG) {
+            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -396,6 +398,10 @@ namespace sharp {
         // From filesystem
         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 "
+              "sharp(Buffer.from('" + descriptor->file.substr(0, 8) + "...')?");
+          }
           throw vips::VError("Input file is missing");
         }
         if (imageType != ImageType::UNKNOWN) {
@@ -403,7 +409,7 @@ namespace sharp {
             vips::VOption *option = VImage::option()
               ->set("access", descriptor->access)
               ->set("fail", descriptor->failOnError);
-            if (imageType == ImageType::SVG) {
+            if (descriptor->unlimited && (imageType == ImageType::SVG || imageType == ImageType::PNG)) {
               option->set("unlimited", TRUE);
             }
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
@@ -488,30 +494,24 @@ namespace sharp {
 
   /*
     Set animation properties if necessary.
-    Non-provided properties will be loaded from image.
   */
-  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop) {
-    bool hasDelay = delay.size() != 1 || delay.front() != -1;
-
-    if (pageHeight == 0 && image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
-      pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
-    }
+  VImage SetAnimationProperties(VImage image, int nPages, int pageHeight, std::vector<int> delay, int loop) {
+    bool hasDelay = !delay.empty();
 
-    if (!hasDelay && image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
-      delay = image.get_array_int("delay");
-      hasDelay = true;
-    }
+    // Avoid a copy if none of the animation properties are needed.
+    if (nPages == 1 && !hasDelay && loop == -1) return image;
 
-    if (loop == -1 && image.get_typeof("loop") == G_TYPE_INT) {
-      loop = image.get_int("loop");
+    if (delay.size() == 1) {
+      // We have just one delay, repeat that value for all frames.
+      delay.insert(delay.end(), nPages - 1, delay[0]);
     }
 
-    if (pageHeight == 0) return image;
-
-    // It is necessary to create the copy as otherwise, pageHeight will be ignored!
+    // Attaching metadata, need to copy the image.
     VImage copy = image.copy();
 
-    copy.set(VIPS_META_PAGE_HEIGHT, pageHeight);
+    // Only set page-height if we have more than one page, or this could
+    // accidentally turn into an animated image later.
+    if (nPages > 1) copy.set(VIPS_META_PAGE_HEIGHT, pageHeight);
     if (hasDelay) copy.set("delay", delay);
     if (loop != -1) copy.set("loop", loop);
 
@@ -554,6 +554,14 @@ namespace sharp {
     return copy;
   }
 
+  /*
+    Multi-page images can have a page height. Fetch it, and sanity check it.
+    If page-height is not set, it defaults to the image height
+  */
+  int GetPageHeight(VImage image) {
+    return vips_image_get_page_height(image.get_image());
+  }
+
   /*
     Check the proposed format supports the current dimensions.
   */
@@ -880,4 +888,79 @@ namespace sharp {
     return image;
   }
 
+  std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
+    Canvas canvas, bool swap, bool withoutEnlargement, bool withoutReduction) {
+    if (swap) {
+      // Swap input width and height when requested.
+      std::swap(width, height);
+    }
+
+    double hshrink = 1.0;
+    double vshrink = 1.0;
+
+    if (targetWidth > 0 && targetHeight > 0) {
+      // Fixed width and height
+      hshrink = static_cast<double>(width) / targetWidth;
+      vshrink = static_cast<double>(height) / targetHeight;
+
+      switch (canvas) {
+        case Canvas::CROP:
+        case Canvas::MIN:
+          if (hshrink < vshrink) {
+            vshrink = hshrink;
+          } else {
+            hshrink = vshrink;
+          }
+          break;
+        case Canvas::EMBED:
+        case Canvas::MAX:
+          if (hshrink > vshrink) {
+            vshrink = hshrink;
+          } else {
+            hshrink = vshrink;
+          }
+          break;
+        case Canvas::IGNORE_ASPECT:
+          if (swap) {
+            std::swap(hshrink, vshrink);
+          }
+          break;
+      }
+    } else if (targetWidth > 0) {
+      // Fixed width
+      hshrink = static_cast<double>(width) / targetWidth;
+
+      if (canvas != Canvas::IGNORE_ASPECT) {
+        // Auto height
+        vshrink = hshrink;
+      }
+    } else if (targetHeight > 0) {
+      // Fixed height
+      vshrink = static_cast<double>(height) / targetHeight;
+
+      if (canvas != Canvas::IGNORE_ASPECT) {
+        // Auto width
+        hshrink = vshrink;
+      }
+    }
+
+    // We should not reduce or enlarge the output image, if
+    // withoutReduction or withoutEnlargement is specified.
+    if (withoutReduction) {
+      // Equivalent of VIPS_SIZE_UP
+      hshrink = std::min(1.0, hshrink);
+      vshrink = std::min(1.0, vshrink);
+    } else if (withoutEnlargement) {
+      // Equivalent of VIPS_SIZE_DOWN
+      hshrink = std::max(1.0, hshrink);
+      vshrink = std::max(1.0, vshrink);
+    }
+
+    // We don't want to shrink so much that we send an axis to 0
+    hshrink = std::min(hshrink, static_cast<double>(width));
+    vshrink = std::min(vshrink, static_cast<double>(height));
+
+    return std::make_pair(hshrink, vshrink);
+  }
+
 }  // namespace sharp

package/src/common.h

@@ -25,9 +25,9 @@
 // Verify platform and compiler compatibility
 
 #if (VIPS_MAJOR_VERSION < 8) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 11) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 11 && VIPS_MICRO_VERSION < 3)
-#error "libvips version 8.11.3+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 12) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 12 && VIPS_MICRO_VERSION < 2)
+#error "libvips version 8.12.2+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -50,6 +50,7 @@ namespace sharp {
     char *buffer;
     bool failOnError;
     int limitInputPixels;
+    bool unlimited;
     VipsAccess access;
     size_t bufferLength;
     bool isBuffer;
@@ -75,6 +76,7 @@ namespace sharp {
       buffer(nullptr),
       failOnError(TRUE),
       limitInputPixels(0x3FFF * 0x3FFF),
+      unlimited(FALSE),
       access(VIPS_ACCESS_RANDOM),
       bufferLength(0),
       isBuffer(FALSE),
@@ -133,6 +135,14 @@ namespace sharp {
     MISSING
   };
 
+  enum class Canvas {
+      CROP,
+      EMBED,
+      MAX,
+      MIN,
+      IGNORE_ASPECT
+  };
+
   // How many tasks are in the queue?
   extern volatile int counterQueue;
 
@@ -206,9 +216,8 @@ namespace sharp {
 
   /*
     Set animation properties if necessary.
-    Non-provided properties will be loaded from image.
   */
-  VImage SetAnimationProperties(VImage image, int pageHeight, std::vector<int> delay, int loop);
+  VImage SetAnimationProperties(VImage image, int nPages, int pageHeight, std::vector<int> delay, int loop);
 
   /*
     Remove animation properties from image.
@@ -230,6 +239,12 @@ namespace sharp {
   */
   VImage SetDensity(VImage image, const double density);
 
+  /*
+    Multi-page images can have a page height. Fetch it, and sanity check it.
+    If page-height is not set, it defaults to the image height
+  */
+  int GetPageHeight(VImage image);
+
   /*
     Check the proposed format supports the current dimensions.
   */
@@ -323,6 +338,15 @@ namespace sharp {
   */
   VImage EnsureAlpha(VImage image, double const value);
 
+  /*
+    Calculate the shrink factor, taking into account auto-rotate, the canvas
+    mode, and so on. The hshrink/vshrink are the amount to shrink the input
+    image axes by in order for the output axes (ie. after rotation) to match
+    the required thumbnail width/height and canvas mode.
+  */
+  std::pair<double, double> ResolveShrink(int width, int height, int targetWidth, int targetHeight,
+    Canvas canvas, bool swap, bool withoutEnlargement, bool withoutReduction);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_

package/src/libvips/cplusplus/VImage.cpp

@@ -93,7 +93,7 @@ negate( std::vector<double> vector )
 {
 	std::vector<double> new_vector( vector.size() );
 
-	for( unsigned int i = 0; i < vector.size(); i++ )
+	for( std::vector<double>::size_type i = 0; i < vector.size(); i++ )
 		new_vector[i] = vector[i] * -1;
 
 	return( new_vector );
@@ -104,7 +104,7 @@ invert( std::vector<double> vector )
 {
 	std::vector<double> new_vector( vector.size() );
 
-	for( unsigned int i = 0; i < vector.size(); i++ )
+	for( std::vector<double>::size_type i = 0; i < vector.size(); i++ )
 		new_vector[i] = 1.0 / vector[i];
 
 	return( new_vector );
@@ -210,7 +210,6 @@ VOption::set( const char *name, std::vector<int> value )
 	Pair *pair = new Pair( name );
 
 	int *array;
-	unsigned int i;
 
 	pair->input = true;
 
@@ -219,7 +218,7 @@ VOption::set( const char *name, std::vector<int> value )
 		static_cast< int >( value.size() ) );
 	array = vips_value_get_array_int( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ ) 
+	for( std::vector<double>::size_type i = 0; i < value.size(); i++ ) 
 		array[i] = value[i];
 
 	options.push_back( pair );
@@ -234,7 +233,6 @@ VOption::set( const char *name, std::vector<double> value )
 	Pair *pair = new Pair( name );
 
 	double *array;
-	unsigned int i;
 
 	pair->input = true;
 
@@ -243,7 +241,7 @@ VOption::set( const char *name, std::vector<double> value )
 		static_cast< int >( value.size() ) );
 	array = vips_value_get_array_double( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ ) 
+	for( std::vector<double>::size_type i = 0; i < value.size(); i++ ) 
 		array[i] = value[i];
 
 	options.push_back( pair );
@@ -258,7 +256,6 @@ VOption::set( const char *name, std::vector<VImage> value )
 	Pair *pair = new Pair( name );
 
 	VipsImage **array;
-	unsigned int i;
 
 	pair->input = true;
 
@@ -267,7 +264,7 @@ VOption::set( const char *name, std::vector<VImage> value )
 		static_cast< int >( value.size() ) );
 	array = vips_value_get_array_image( &pair->value, NULL );
 
-	for( i = 0; i < value.size(); i++ ) {
+	for( std::vector<double>::size_type i = 0; i < value.size(); i++ ) {
 		VipsImage *vips_image = value[i].get_image();
 
 		array[i] = vips_image;
@@ -488,10 +485,9 @@ VOption::get_operation( VipsOperation *operation )
 				double *array =
 					vips_value_get_array_double( value,
 					&length );
-				int j;
 
 				((*i)->vvector)->resize( length );
-				for( j = 0; j < length; j++ )
+				for( int j = 0; j < length; j++ )
 					(*((*i)->vvector))[j] = array[j];
 			}
 			else if( type == VIPS_TYPE_BLOB ) {
@@ -718,17 +714,38 @@ VImage::write_to_buffer( const char *suffix, void **buf, size_t *size,
 	const char *operation_name;
 	VipsBlob *blob;
 
+	/* Save with the new target API if we can. Fall back to the older
+	 * mechanism in case the saver we need has not been converted yet.
+	 *
+	 * We need to hide any errors from this first phase.
+	 */
 	vips__filename_split8( suffix, filename, option_string );
-	if( !(operation_name = vips_foreign_find_save_buffer( filename )) ) {
+
+	vips_error_freeze();
+	operation_name = vips_foreign_find_save_target( filename );
+	vips_error_thaw();
+
+	if( operation_name ) {
+		VTarget target = VTarget::new_to_memory();
+
+		call_option_string( operation_name, option_string,
+			(options ? options : VImage::option())->
+				set( "in", *this )->
+				set( "target", target ) );
+
+		g_object_get( target.get_target(), "blob", &blob, NULL );
+	}
+	else if( (operation_name = vips_foreign_find_save_buffer( filename )) ) {
+		call_option_string( operation_name, option_string,
+			(options ? options : VImage::option())->
+				set( "in", *this )->
+				set( "buffer", &blob ) );
+	}
+	else {
 		delete options;
 		throw VError();
 	}
 
-	call_option_string( operation_name, option_string,
-		(options ? options : VImage::option())->
-			set( "in", *this )->
-			set( "buffer", &blob ) );
-
 	if( blob ) {
 		if( buf ) {
 			*buf = VIPS_AREA( blob )->data;
@@ -767,6 +784,7 @@ std::vector<VImage>
 VImage::bandsplit( VOption *options ) const
 {
 	std::vector<VImage> b;
+	b.reserve(bands());
 
 	for( int i = 0; i < bands(); i++ )
 		b.push_back( extract_band( i ) );

package/src/libvips/cplusplus/vips-operators.cpp

@@ -1,5 +1,5 @@
 // bodies for vips operations
-// Wed May 12 11:30:00 AM CEST 2021
+// Mon Nov  1 03:31:09 PM CET 2021
 // this file is generated automatically, do not edit!
 
 VImage VImage::CMC2LCh( VOption *options ) const
@@ -1262,6 +1262,34 @@ VImage VImage::gifload_source( VSource source, VOption *options )
     return( out );
 }
 
+void VImage::gifsave( const char *filename, VOption *options ) const
+{
+    call( "gifsave",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "filename", filename ) );
+}
+
+VipsBlob *VImage::gifsave_buffer( VOption *options ) const
+{
+    VipsBlob *buffer;
+
+    call( "gifsave_buffer",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "buffer", &buffer ) );
+
+    return( buffer );
+}
+
+void VImage::gifsave_target( VTarget target, VOption *options ) const
+{
+    call( "gifsave_target",
+        (options ? options : VImage::option())->
+            set( "in", *this )->
+            set( "target", target ) );
+}
+
 VImage VImage::globalbalance( VOption *options ) const
 {
     VImage out;

package/src/metadata.cc

@@ -77,6 +77,9 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (image.get_typeof("heif-compression") == VIPS_TYPE_REF_STRING) {
         baton->compression = image.get_string("heif-compression");
       }
+      if (image.get_typeof(VIPS_META_RESOLUTION_UNIT) == VIPS_TYPE_REF_STRING) {
+        baton->resolutionUnit = image.get_string(VIPS_META_RESOLUTION_UNIT);
+      }
       if (image.get_typeof("openslide.level-count") == VIPS_TYPE_REF_STRING) {
         int const levels = std::stoi(image.get_string("openslide.level-count"));
         for (int l = 0; l < levels; l++) {
@@ -198,6 +201,9 @@ class MetadataWorker : public Napi::AsyncWorker {
       if (!baton->compression.empty()) {
         info.Set("compression", baton->compression);
       }
+      if (!baton->resolutionUnit.empty()) {
+        info.Set("resolutionUnit", baton->resolutionUnit == "in" ? "inch" : baton->resolutionUnit);
+      }
       if (!baton->levels.empty()) {
         int i = 0;
         Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));

package/src/metadata.h

@@ -40,6 +40,7 @@ struct MetadataBaton {
   std::vector<int> delay;
   int pagePrimary;
   std::string compression;
+  std::string resolutionUnit;
   std::vector<std::pair<int, int>> levels;
   int subifds;
   std::vector<double> background;

package/src/operations.cc

@@ -308,4 +308,98 @@ namespace sharp {
     return image;
   }
 
+  /*
+   * Split and crop each frame, reassemble, and update pageHeight.
+   */
+  VImage CropMultiPage(VImage image, int left, int top, int width, int height,
+                       int nPages, int *pageHeight) {
+    if (top == 0 && height == *pageHeight) {
+      // Fast path; no need to adjust the height of the multi-page image
+      return image.extract_area(left, 0, width, image.height());
+    } else {
+      std::vector<VImage> pages;
+      pages.reserve(nPages);
+
+      // Split the image into cropped frames
+      for (int i = 0; i < nPages; i++) {
+        pages.push_back(
+          image.extract_area(left, *pageHeight * i + top, width, height));
+      }
+
+      // Reassemble the frames into a tall, thin image
+      VImage assembled = VImage::arrayjoin(pages,
+        VImage::option()->set("across", 1));
+
+      // Update the page height
+      *pageHeight = height;
+
+      return assembled;
+    }
+  }
+
+  /*
+   * Split into frames, embed each frame, reassemble, and update pageHeight.
+   */
+  VImage EmbedMultiPage(VImage image, int left, int top, int width, int height,
+                        std::vector<double> background, int nPages, int *pageHeight) {
+    if (top == 0 && height == *pageHeight) {
+      // Fast path; no need to adjust the height of the multi-page image
+      return image.embed(left, 0, width, image.height(), VImage::option()
+        ->set("extend", VIPS_EXTEND_BACKGROUND)
+        ->set("background", background));
+    } else if (left == 0 && width == image.width()) {
+      // Fast path; no need to adjust the width of the multi-page image
+      std::vector<VImage> pages;
+      pages.reserve(nPages);
+
+      // Rearrange the tall image into a vertical grid
+      image = image.grid(*pageHeight, nPages, 1);
+
+      // Do the embed on the wide image
+      image = image.embed(0, top, image.width(), height, VImage::option()
+        ->set("extend", VIPS_EXTEND_BACKGROUND)
+        ->set("background", background));
+
+      // Split the wide image into frames
+      for (int i = 0; i < nPages; i++) {
+        pages.push_back(
+          image.extract_area(width * i, 0, width, height));
+      }
+
+      // Reassemble the frames into a tall, thin image
+      VImage assembled = VImage::arrayjoin(pages,
+        VImage::option()->set("across", 1));
+
+      // Update the page height
+      *pageHeight = height;
+
+      return assembled;
+    } else {
+      std::vector<VImage> pages;
+      pages.reserve(nPages);
+
+      // Split the image into frames
+      for (int i = 0; i < nPages; i++) {
+        pages.push_back(
+          image.extract_area(0, *pageHeight * i, image.width(), *pageHeight));
+      }
+
+      // Embed each frame in the target size
+      for (int i = 0; i < nPages; i++) {
+        pages[i] = pages[i].embed(left, top, width, height, VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background));
+      }
+
+      // Reassemble the frames into a tall, thin image
+      VImage assembled = VImage::arrayjoin(pages,
+        VImage::option()->set("across", 1));
+
+      // Update the page height
+      *pageHeight = height;
+
+      return assembled;
+    }
+  }
+
 }  // namespace sharp

package/src/operations.h

@@ -108,6 +108,18 @@ namespace sharp {
    */
   VImage EnsureColourspace(VImage image, VipsInterpretation colourspace);
 
+  /*
+   * Split and crop each frame, reassemble, and update pageHeight.
+   */
+  VImage CropMultiPage(VImage image, int left, int top, int width, int height,
+                       int nPages, int *pageHeight);
+
+  /*
+   * Split into frames, embed each frame, reassemble, and update pageHeight.
+   */
+  VImage EmbedMultiPage(VImage image, int left, int top, int width, int height,
+                        std::vector<double> background, int nPages, int *pageHeight);
+
 }  // namespace sharp
 
 #endif  // SRC_OPERATIONS_H_