sharp 0.32.5 → 0.33.0-alpha.10

package/{binding.gyp → src/binding.gyp}

@@ -1,8 +1,14 @@
+# Copyright 2013 Lovell Fuller and others.
+# SPDX-License-Identifier: Apache-2.0
+
 {
   'variables': {
-    'vips_version': '<!(node -p "require(\'./lib/libvips\').minimumLibvipsVersion")',
-    'platform_and_arch': '<!(node -p "require(\'./lib/platform\')()")',
-    'sharp_vendor_dir': './vendor/<(vips_version)/<(platform_and_arch)'
+    'vips_version': '<!(node -p "require(\'../lib/libvips\').minimumLibvipsVersion")',
+    'platform_and_arch': '<!(node -p "require(\'../lib/libvips\').buildPlatformArch()")',
+    'sharp_libvips_version': '<!(node -p "require(\'../package.json\').optionalDependencies[\'@img/sharp-libvips-<(platform_and_arch)\']")',
+    'sharp_libvips_include_dir': '<!(node -p "require(\'../lib/libvips\').buildSharpLibvipsIncludeDir()")',
+    'sharp_libvips_cplusplus_dir': '<!(node -p "require(\'../lib/libvips\').buildSharpLibvipsCPlusPlusDir()")',
+    'sharp_libvips_lib_dir': '<!(node -p "require(\'../lib/libvips\').buildSharpLibvipsLibDir()")'
   },
   'targets': [{
     'target_name': 'libvips-cpp',
@@ -15,23 +21,23 @@
           '_ALLOW_KEYWORD_MACROS'
         ],
         'sources': [
-          'src/libvips/cplusplus/VConnection.cpp',
-          'src/libvips/cplusplus/VError.cpp',
-          'src/libvips/cplusplus/VImage.cpp',
-          'src/libvips/cplusplus/VInterpolate.cpp',
-          'src/libvips/cplusplus/VRegion.cpp'
+          '<(sharp_libvips_cplusplus_dir)/VConnection.cpp',
+          '<(sharp_libvips_cplusplus_dir)/VError.cpp',
+          '<(sharp_libvips_cplusplus_dir)/VImage.cpp',
+          '<(sharp_libvips_cplusplus_dir)/VInterpolate.cpp',
+          '<(sharp_libvips_cplusplus_dir)/VRegion.cpp'
         ],
         'include_dirs': [
-          '<(sharp_vendor_dir)/include',
-          '<(sharp_vendor_dir)/include/glib-2.0',
-          '<(sharp_vendor_dir)/lib/glib-2.0/include'
+          '<(sharp_libvips_include_dir)',
+          '<(sharp_libvips_include_dir)/glib-2.0',
+          '<(sharp_libvips_lib_dir)/glib-2.0/include'
         ],
         'link_settings': {
-          'library_dirs': ['<(sharp_vendor_dir)/lib'],
+          'library_dirs': [
+            '<(sharp_libvips_lib_dir)'
+          ],
           'libraries': [
-            'libvips.lib',
-            'libglib-2.0.lib',
-            'libgobject-2.0.lib'
+            'libvips.lib'
           ],
         },
         'configurations': {
@@ -70,7 +76,7 @@
   }, {
     'target_name': 'sharp-<(platform_and_arch)',
     'defines': [
-      'NAPI_VERSION=7',
+      'NAPI_VERSION=9',
       'NODE_ADDON_API_DISABLE_DEPRECATED',
       'NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS'
     ],
@@ -79,11 +85,10 @@
       'libvips-cpp'
     ],
     'variables': {
-      'runtime_link%': 'shared',
       'conditions': [
         ['OS != "win"', {
-          'pkg_config_path': '<!(node -p "require(\'./lib/libvips\').pkgConfigPath()")',
-          'use_global_libvips': '<!(node -p "Boolean(require(\'./lib/libvips\').useGlobalLibvips()).toString()")'
+          'pkg_config_path': '<!(node -p "require(\'../lib/libvips\').pkgConfigPath()")',
+          'use_global_libvips': '<!(node -p "Boolean(require(\'../lib/libvips\').useGlobalLibvips()).toString()")'
         }, {
           'pkg_config_path': '',
           'use_global_libvips': ''
@@ -91,13 +96,13 @@
       ]
     },
     'sources': [
-      'src/common.cc',
-      'src/metadata.cc',
-      'src/stats.cc',
-      'src/operations.cc',
-      'src/pipeline.cc',
-      'src/utilities.cc',
-      'src/sharp.cc'
+      'common.cc',
+      'metadata.cc',
+      'stats.cc',
+      'operations.cc',
+      'pipeline.cc',
+      'utilities.cc',
+      'sharp.cc'
     ],
     'include_dirs': [
       '<!(node -p "require(\'node-addon-api\').include_dir")',
@@ -106,12 +111,11 @@
       ['use_global_libvips == "true"', {
         # Use pkg-config for include and lib
         'include_dirs': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --cflags-only-I vips-cpp vips glib-2.0 | sed s\/-I//g)'],
+        'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs vips-cpp)'],
+        'defines': [
+          'SHARP_USE_GLOBAL_LIBVIPS'
+        ],
         'conditions': [
-          ['runtime_link == "static"', {
-            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs --static vips-cpp)']
-          }, {
-            'libraries': ['<!@(PKG_CONFIG_PATH="<(pkg_config_path)" pkg-config --libs vips-cpp)']
-          }],
           ['OS == "linux"', {
             'defines': [
               # Inspect libvips-cpp.so to determine which C++11 ABI version was used and set _GLIBCXX_USE_CXX11_ABI accordingly. This is quite horrible.
@@ -122,9 +126,12 @@
       }, {
         # Use pre-built libvips stored locally within node_modules
         'include_dirs': [
-          '<(sharp_vendor_dir)/include',
-          '<(sharp_vendor_dir)/include/glib-2.0',
-          '<(sharp_vendor_dir)/lib/glib-2.0/include'
+          '<(sharp_libvips_include_dir)',
+          '<(sharp_libvips_include_dir)/glib-2.0',
+          '<(sharp_libvips_lib_dir)/glib-2.0/include'
+        ],
+        'library_dirs': [
+          '<(sharp_libvips_lib_dir)'
         ],
         'conditions': [
           ['OS == "win"', {
@@ -133,17 +140,13 @@
               '_FILE_OFFSET_BITS=64'
             ],
             'link_settings': {
-              'library_dirs': ['<(sharp_vendor_dir)/lib'],
               'libraries': [
-                'libvips.lib',
-                'libglib-2.0.lib',
-                'libgobject-2.0.lib'
+                'libvips.lib'
               ]
             }
           }],
           ['OS == "mac"', {
             'link_settings': {
-              'library_dirs': ['../<(sharp_vendor_dir)/lib'],
               'libraries': [
                 'libvips-cpp.42.dylib'
               ]
@@ -151,7 +154,10 @@
             'xcode_settings': {
               'OTHER_LDFLAGS': [
                 # Ensure runtime linking is relative to sharp.node
-                '-Wl,-rpath,\'@loader_path/../../<(sharp_vendor_dir)/lib\''
+                '-Wl,-rpath,\'@loader_path/../../sharp-libvips-<(platform_and_arch)/lib\'',
+                '-Wl,-rpath,\'@loader_path/../../../<(sharp_libvips_version)/sharp-libvips-<(platform_and_arch)/lib\'',
+                '-Wl,-rpath,\'@loader_path/../../node_modules/@img/sharp-libvips-<(platform_and_arch)/lib\'',
+                '-Wl,-rpath,\'@loader_path/../../../node_modules/@img/sharp-libvips-<(platform_and_arch)/lib\''
               ]
             }
           }],
@@ -160,13 +166,17 @@
               '_GLIBCXX_USE_CXX11_ABI=1'
             ],
             'link_settings': {
-              'library_dirs': ['../<(sharp_vendor_dir)/lib'],
               'libraries': [
                 '-l:libvips-cpp.so.42'
               ],
               'ldflags': [
                 # Ensure runtime linking is relative to sharp.node
-                '-Wl,-s -Wl,--disable-new-dtags -Wl,-rpath=\'$$ORIGIN/../../<(sharp_vendor_dir)/lib\''
+                '-Wl,-s',
+                '-Wl,--disable-new-dtags',
+                '-Wl,-rpath=\'$$ORIGIN/../../sharp-libvips-<(platform_and_arch)/lib\'',
+                '-Wl,-rpath=\'$$ORIGIN/../../../<(sharp_libvips_version)/sharp-libvips-<(platform_and_arch)/lib\'',
+                '-Wl,-rpath=\'$$ORIGIN/../../node_modules/@img/sharp-libvips-<(platform_and_arch)/lib\'',
+                '-Wl,-rpath=\'$$ORIGIN/../../../node_modules/@img/sharp-libvips-<(platform_and_arch)/lib\''
               ]
             }
           }]
@@ -232,5 +242,21 @@
         ]
       }
     },
+  }, {
+    'target_name': 'copy-dll',
+    'type': 'none',
+    'dependencies': [
+      'sharp-<(platform_and_arch)'
+    ],
+    'conditions': [
+      ['OS == "win"', {
+        'copies': [{
+          'destination': 'build/Release',
+          'files': [
+            '<(sharp_libvips_lib_dir)/libvips-42.dll'
+          ]
+        }]
+      }]
+    ]
   }]
 }

package/src/common.cc

@@ -166,10 +166,10 @@ namespace sharp {
   }
 
   // How many tasks are in the queue?
-  volatile int counterQueue = 0;
+  std::atomic<int> counterQueue{0};
 
   // How many tasks are being processed?
-  volatile int counterProcess = 0;
+  std::atomic<int> counterProcess{0};
 
   // Filename extension checkers
   static bool EndsWith(std::string const &str, std::string const &end) {
@@ -363,12 +363,13 @@ namespace sharp {
     if (descriptor->isBuffer) {
       if (descriptor->rawChannels > 0) {
         // Raw, uncompressed pixel data
+        bool const is8bit = vips_band_format_is8bit(descriptor->rawDepth);
         image = VImage::new_from_memory(descriptor->buffer, descriptor->bufferLength,
           descriptor->rawWidth, descriptor->rawHeight, descriptor->rawChannels, descriptor->rawDepth);
         if (descriptor->rawChannels < 3) {
-          image.get_image()->Type = VIPS_INTERPRETATION_B_W;
+          image.get_image()->Type = is8bit ? VIPS_INTERPRETATION_B_W : VIPS_INTERPRETATION_GREY16;
         } else {
-          image.get_image()->Type = VIPS_INTERPRETATION_sRGB;
+          image.get_image()->Type = is8bit ? VIPS_INTERPRETATION_sRGB : VIPS_INTERPRETATION_RGB16;
         }
         if (descriptor->rawPremultiplied) {
           image = image.unpremultiply();

package/src/common.h

@@ -7,6 +7,7 @@
 #include <string>
 #include <tuple>
 #include <vector>
+#include <atomic>
 
 #include <napi.h>
 #include <vips/vips8>
@@ -14,9 +15,9 @@
 // Verify platform and compiler compatibility
 
 #if (VIPS_MAJOR_VERSION < 8) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 14) || \
-  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 14 && VIPS_MICRO_VERSION < 4)
-#error "libvips version 8.14.4+ is required - please see https://sharp.pixelplumbing.com/install"
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 15) || \
+  (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION == 15 && VIPS_MICRO_VERSION < 0)
+#error "libvips version 8.15.0+ is required - please see https://sharp.pixelplumbing.com/install"
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
@@ -161,10 +162,10 @@ namespace sharp {
   };
 
   // How many tasks are in the queue?
-  extern volatile int counterQueue;
+  extern std::atomic<int> counterQueue;
 
   // How many tasks are being processed?
-  extern volatile int counterProcess;
+  extern std::atomic<int> counterProcess;
 
   // Filename extension checkers
   bool IsJpeg(std::string const &str);

package/src/metadata.cc

@@ -18,7 +18,7 @@ class MetadataWorker : public Napi::AsyncWorker {
 
   void Execute() {
     // Decrement queued task counter
-    g_atomic_int_dec_and_test(&sharp::counterQueue);
+    sharp::counterQueue--;
 
     vips::VImage image;
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
@@ -145,7 +145,7 @@ class MetadataWorker : public Napi::AsyncWorker {
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      debuglog.MakeCallback(Receiver().Value(), { Napi::String::New(env, warning) });
+      debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
@@ -246,9 +246,9 @@ class MetadataWorker : public Napi::AsyncWorker {
           Napi::Buffer<char>::NewOrCopy(env, baton->tifftagPhotoshop,
             baton->tifftagPhotoshopLength, sharp::FreeCallback));
       }
-      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+      Callback().Call(Receiver().Value(), { env.Null(), info });
     } else {
-      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
+      Callback().Call(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
     }
 
     delete baton->input;
@@ -281,7 +281,7 @@ Napi::Value metadata(const Napi::CallbackInfo& info) {
   worker->Queue();
 
   // Increment queued task counter
-  g_atomic_int_inc(&sharp::counterQueue);
+  sharp::counterQueue++;
 
   return info.Env().Undefined();
 }

package/src/operations.cc

@@ -141,7 +141,7 @@ namespace sharp {
       return image.conv(blur);
     } else {
       // Slower, accurate Gaussian blur
-      return image.gaussblur(sigma);
+      return StaySequential(image, VIPS_ACCESS_SEQUENTIAL).gaussblur(sigma);
     }
   }
 
@@ -265,7 +265,7 @@ namespace sharp {
   /*
     Trim an image
   */
-  VImage Trim(VImage image, std::vector<double> background, double threshold) {
+  VImage Trim(VImage image, std::vector<double> background, double threshold, bool const lineArt) {
     if (image.width() < 3 && image.height() < 3) {
       throw VError("Image to trim must be at least 3x3 pixels");
     }
@@ -287,6 +287,7 @@ namespace sharp {
     int left, top, width, height;
     left = image.find_trim(&top, &width, &height, VImage::option()
       ->set("background", background)
+      ->set("line_art", lineArt)
       ->set("threshold", threshold));
     if (HasAlpha(image)) {
       // Search alpha channel (A)
@@ -294,6 +295,7 @@ namespace sharp {
       VImage alpha = image[image.bands() - 1];
       leftA = alpha.find_trim(&topA, &widthA, &heightA, VImage::option()
         ->set("background", backgroundAlpha)
+        ->set("line_art", lineArt)
         ->set("threshold", threshold));
       if (widthA > 0 && heightA > 0) {
         if (width > 0 && height > 0) {
@@ -370,6 +372,7 @@ namespace sharp {
       pages.reserve(nPages);
 
       // Split the image into cropped frames
+      image = StaySequential(image, VIPS_ACCESS_SEQUENTIAL);
       for (int i = 0; i < nPages; i++) {
         pages.push_back(
           image.extract_area(left, *pageHeight * i + top, width, height));

package/src/operations.h

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

package/src/pipeline.cc

@@ -44,9 +44,9 @@ class PipelineWorker : public Napi::AsyncWorker {
   // libuv worker
   void Execute() {
     // Decrement queued task counter
-    g_atomic_int_dec_and_test(&sharp::counterQueue);
+    sharp::counterQueue--;
     // Increment processing task counter
-    g_atomic_int_inc(&sharp::counterProcess);
+    sharp::counterProcess++;
 
     try {
       // Open input
@@ -126,10 +126,10 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Trim
-      if (baton->trimThreshold > 0.0) {
+      if (baton->trimThreshold >= 0.0) {
         MultiPageUnsupported(nPages, "Trim");
         image = sharp::StaySequential(image, access);
-        image = sharp::Trim(image, baton->trimBackground, baton->trimThreshold);
+        image = sharp::Trim(image, baton->trimBackground, baton->trimThreshold, baton->trimLineArt);
         baton->trimOffsetLeft = image.xoffset();
         baton->trimOffsetTop = image.yoffset();
       }
@@ -182,7 +182,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       //  - trimming or pre-resize extract isn't required;
       //  - input colourspace is not specified;
       bool const shouldPreShrink = (targetResizeWidth > 0 || targetResizeHeight > 0) &&
-        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold == 0.0 &&
+        baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold < 0.0 &&
         baton->colourspaceInput == VIPS_INTERPRETATION_LAST && !shouldRotateBefore;
 
       if (shouldPreShrink) {
@@ -326,7 +326,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         try {
           image = image.icc_transform(processingProfile, VImage::option()
             ->set("embedded", TRUE)
-            ->set("depth", image.interpretation() == VIPS_INTERPRETATION_RGB16 ? 16 : 8)
+            ->set("depth", sharp::Is16Bit(image.interpretation()) ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
         } catch(...) {
           sharp::VipsWarningCallback(nullptr, G_LOG_LEVEL_WARNING, "Invalid embedded profile", nullptr);
@@ -485,9 +485,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             image = sharp::StaySequential(image, access);
             image = image.smartcrop(baton->width, baton->height, VImage::option()
               ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION)
-#if (VIPS_MAJOR_VERSION >= 8 && VIPS_MINOR_VERSION >= 15)
               ->set("premultiplied", shouldPremultiplyAlpha)
-#endif
               ->set("attention_x", &attention_x)
               ->set("attention_y", &attention_y));
             baton->hasCropOffset = true;
@@ -653,7 +651,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             if (across != 0 || down != 0) {
               int left;
               int top;
-              compositeImage = compositeImage.replicate(across, down);
+              compositeImage = sharp::StaySequential(compositeImage, access).replicate(across, down);
               if (composite->hasOffset) {
                 std::tie(left, top) = sharp::CalculateCrop(
                   compositeImage.width(), compositeImage.height(), image.width(), image.height(),
@@ -763,6 +761,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         if (baton->withMetadata && sharp::HasProfile(image) && baton->withMetadataIcc.empty()) {
           image = image.icc_transform("srgb", VImage::option()
             ->set("embedded", TRUE)
+            ->set("depth", sharp::Is16Bit(image.interpretation()) ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
         }
       }
@@ -794,6 +793,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           VImage::option()
             ->set("input_profile", processingProfile)
             ->set("embedded", TRUE)
+            ->set("depth", sharp::Is16Bit(image.interpretation()) ? 16 : 8)
             ->set("intent", VIPS_INTENT_PERCEPTUAL));
       }
       // Override EXIF Orientation tag
@@ -938,6 +938,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("Q", baton->tiffQuality)
             ->set("bitdepth", baton->tiffBitdepth)
             ->set("compression", baton->tiffCompression)
+            ->set("miniswhite", baton->tiffMiniswhite)
             ->set("predictor", baton->tiffPredictor)
             ->set("pyramid", baton->tiffPyramid)
             ->set("tile", baton->tiffTile)
@@ -1134,6 +1135,7 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("Q", baton->tiffQuality)
             ->set("bitdepth", baton->tiffBitdepth)
             ->set("compression", baton->tiffCompression)
+            ->set("miniswhite", baton->tiffMiniswhite)
             ->set("predictor", baton->tiffPredictor)
             ->set("pyramid", baton->tiffPyramid)
             ->set("tile", baton->tiffTile)
@@ -1213,7 +1215,7 @@ class PipelineWorker : public Napi::AsyncWorker {
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      debuglog.MakeCallback(Receiver().Value(), { Napi::String::New(env, warning) });
+      debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
@@ -1246,11 +1248,10 @@ class PipelineWorker : public Napi::AsyncWorker {
         info.Set("attentionX", static_cast<int32_t>(baton->attentionX));
         info.Set("attentionY", static_cast<int32_t>(baton->attentionY));
       }
-      if (baton->trimThreshold > 0.0) {
+      if (baton->trimThreshold >= 0.0) {
         info.Set("trimOffsetLeft", static_cast<int32_t>(baton->trimOffsetLeft));
         info.Set("trimOffsetTop", static_cast<int32_t>(baton->trimOffsetTop));
       }
-
       if (baton->input->textAutofitDpi) {
         info.Set("textAutofitDpi", static_cast<uint32_t>(baton->input->textAutofitDpi));
       }
@@ -1261,17 +1262,17 @@ class PipelineWorker : public Napi::AsyncWorker {
         // Pass ownership of output data to Buffer instance
         Napi::Buffer<char> data = Napi::Buffer<char>::NewOrCopy(env, static_cast<char*>(baton->bufferOut),
           baton->bufferOutLength, sharp::FreeCallback);
-        Callback().MakeCallback(Receiver().Value(), { env.Null(), data, info });
+        Callback().Call(Receiver().Value(), { env.Null(), data, info });
       } else {
         // Add file size to info
         struct STAT64_STRUCT st;
         if (STAT64_FUNCTION(baton->fileOut.data(), &st) == 0) {
           info.Set("size", static_cast<uint32_t>(st.st_size));
         }
-        Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+        Callback().Call(Receiver().Value(), { env.Null(), info });
       }
     } else {
-      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
+      Callback().Call(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
     }
 
     // Delete baton
@@ -1287,9 +1288,9 @@ class PipelineWorker : public Napi::AsyncWorker {
     delete baton;
 
     // Decrement processing task counter
-    g_atomic_int_dec_and_test(&sharp::counterProcess);
-    Napi::Number queueLength = Napi::Number::New(env, static_cast<double>(sharp::counterQueue));
-    queueListener.MakeCallback(Receiver().Value(), { queueLength });
+    sharp::counterProcess--;
+    Napi::Number queueLength = Napi::Number::New(env, static_cast<int>(sharp::counterQueue));
+    queueListener.Call(Receiver().Value(), { queueLength });
   }
 
  private:
@@ -1517,6 +1518,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->thresholdGrayscale = sharp::AttrAsBool(options, "thresholdGrayscale");
   baton->trimBackground = sharp::AttrAsVectorOfDouble(options, "trimBackground");
   baton->trimThreshold = sharp::AttrAsDouble(options, "trimThreshold");
+  baton->trimLineArt = sharp::AttrAsBool(options, "trimLineArt");
   baton->gamma = sharp::AttrAsDouble(options, "gamma");
   baton->gammaOut = sharp::AttrAsDouble(options, "gammaOut");
   baton->linearA = sharp::AttrAsVectorOfDouble(options, "linearA");
@@ -1645,6 +1647,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->gifProgressive = sharp::AttrAsBool(options, "gifProgressive");
   baton->tiffQuality = sharp::AttrAsUint32(options, "tiffQuality");
   baton->tiffPyramid = sharp::AttrAsBool(options, "tiffPyramid");
+  baton->tiffMiniswhite = sharp::AttrAsBool(options, "tiffMiniswhite");
   baton->tiffBitdepth = sharp::AttrAsUint32(options, "tiffBitdepth");
   baton->tiffTile = sharp::AttrAsBool(options, "tiffTile");
   baton->tiffTileWidth = sharp::AttrAsUint32(options, "tiffTileWidth");
@@ -1705,9 +1708,8 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   worker->Queue();
 
   // Increment queued task counter
-  g_atomic_int_inc(&sharp::counterQueue);
-  Napi::Number queueLength = Napi::Number::New(info.Env(), static_cast<double>(sharp::counterQueue));
-  queueListener.MakeCallback(info.This(), { queueLength });
+  Napi::Number queueLength = Napi::Number::New(info.Env(), static_cast<int>(++sharp::counterQueue));
+  queueListener.Call(info.This(), { queueLength });
 
   return info.Env().Undefined();
 }

package/src/pipeline.h

@@ -92,6 +92,7 @@ struct PipelineBaton {
   bool thresholdGrayscale;
   std::vector<double> trimBackground;
   double trimThreshold;
+  bool trimLineArt;
   int trimOffsetLeft;
   int trimOffsetTop;
   std::vector<double> linearA;
@@ -169,6 +170,7 @@ struct PipelineBaton {
   VipsForeignTiffPredictor tiffPredictor;
   bool tiffPyramid;
   int tiffBitdepth;
+  bool tiffMiniswhite;
   bool tiffTile;
   int tiffTileHeight;
   int tiffTileWidth;
@@ -259,7 +261,8 @@ struct PipelineBaton {
     threshold(0),
     thresholdGrayscale(true),
     trimBackground{},
-    trimThreshold(0.0),
+    trimThreshold(-1.0),
+    trimLineArt(false),
     trimOffsetLeft(0),
     trimOffsetTop(0),
     linearA{},
@@ -335,6 +338,7 @@ struct PipelineBaton {
     tiffPredictor(VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL),
     tiffPyramid(false),
     tiffBitdepth(8),
+    tiffMiniswhite(false),
     tiffTile(false),
     tiffTileHeight(256),
     tiffTileWidth(256),

package/src/sharp.cc

@@ -1,6 +1,8 @@
 // Copyright 2013 Lovell Fuller and others.
 // SPDX-License-Identifier: Apache-2.0
 
+#include <mutex>  // NOLINT(build/c++11)
+
 #include <napi.h>
 #include <vips/vips8>
 
@@ -10,14 +12,11 @@
 #include "utilities.h"
 #include "stats.h"
 
-static void* sharp_vips_init(void*) {
-  vips_init("sharp");
-  return nullptr;
-}
-
 Napi::Object init(Napi::Env env, Napi::Object exports) {
-  static GOnce sharp_vips_init_once = G_ONCE_INIT;
-  g_once(&sharp_vips_init_once, static_cast<GThreadFunc>(sharp_vips_init), nullptr);
+  static std::once_flag sharp_vips_init_once;
+  std::call_once(sharp_vips_init_once, []() {
+    vips_init("sharp");
+  });
 
   g_log_set_handler("VIPS", static_cast<GLogLevelFlags>(G_LOG_LEVEL_WARNING),
     static_cast<GLogFunc>(sharp::VipsWarningCallback), nullptr);

package/src/stats.cc

@@ -30,7 +30,7 @@ class StatsWorker : public Napi::AsyncWorker {
 
   void Execute() {
     // Decrement queued task counter
-    g_atomic_int_dec_and_test(&sharp::counterQueue);
+    sharp::counterQueue--;
 
     vips::VImage image;
     sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
@@ -106,7 +106,7 @@ class StatsWorker : public Napi::AsyncWorker {
     // Handle warnings
     std::string warning = sharp::VipsWarningPop();
     while (!warning.empty()) {
-      debuglog.MakeCallback(Receiver().Value(), { Napi::String::New(env, warning) });
+      debuglog.Call(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
@@ -141,9 +141,9 @@ class StatsWorker : public Napi::AsyncWorker {
       dominant.Set("g", baton->dominantGreen);
       dominant.Set("b", baton->dominantBlue);
       info.Set("dominant", dominant);
-      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+      Callback().Call(Receiver().Value(), { env.Null(), info });
     } else {
-      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
+      Callback().Call(Receiver().Value(), { Napi::Error::New(env, sharp::TrimEnd(baton->err)).Value() });
     }
 
     delete baton->input;
@@ -177,7 +177,7 @@ Napi::Value stats(const Napi::CallbackInfo& info) {
   worker->Queue();
 
   // Increment queued task counter
-  g_atomic_int_inc(&sharp::counterQueue);
+  sharp::counterQueue++;
 
   return info.Env().Undefined();
 }