@revizly/sharp 0.35.0-revizly22 → 0.35.0-revizly24

package/lib/constructor.js

@@ -315,6 +315,7 @@ const Sharp = function (input, options) {
     withExif: {},
     withExifMerge: true,
     withXmp: '',
+    keepGainMap: false,
     withGainMap: false,
     resolveWithObject: false,
     loop: -1,

package/lib/libvips.js

@@ -37,13 +37,13 @@ const log = (item) => {
   }
 };
 
-/* node:coverage ignore next */
+/* node:coverage disable */
+
 const runtimeLibc = () => detectLibc.isNonGlibcLinuxSync() ? detectLibc.familySync() : '';
 
 const runtimePlatformArch = () => `${process.platform}${runtimeLibc()}-${process.arch}`;
 
 const buildPlatformArch = () => {
-  /* node:coverage ignore next 3 */
   if (isEmscripten()) {
     return 'wasm32';
   }
@@ -56,7 +56,6 @@ const buildSharpLibvipsIncludeDir = () => {
   try {
     return require(`@revizly/sharp-libvips-dev-${buildPlatformArch()}/include`);
   } catch {
-    /* node:coverage ignore next 5 */
     try {
       return require('@revizly/sharp-libvips-dev/include');
     } catch {}
@@ -65,7 +64,6 @@ const buildSharpLibvipsIncludeDir = () => {
 };
 
 const buildSharpLibvipsCPlusPlusDir = () => {
-  /* node:coverage ignore next 4 */
   try {
     return require('@revizly/sharp-libvips-dev/cplusplus');
   } catch {}
@@ -76,7 +74,6 @@ const buildSharpLibvipsLibDir = () => {
   try {
     return require(`@revizly/sharp-libvips-dev-${buildPlatformArch()}/lib`);
   } catch {
-    /* node:coverage ignore next 5 */
     try {
       return require(`@revizly/sharp-libvips-${buildPlatformArch()}/lib`);
     } catch {}
@@ -84,8 +81,6 @@ const buildSharpLibvipsLibDir = () => {
   return '';
 };
 
-/* node:coverage disable */
-
 const isUnsupportedNodeRuntime = () => {
   if (process.release?.name === 'node' && process.versions) {
     if (!semverSatisfies(process.versions.node, engines.node)) {
@@ -151,9 +146,17 @@ const getBrewPkgConfigPath = () => {
     if (brewPrefix) {
       return `${brewPrefix}/lib/pkgconfig`;
     }
-  } catch (_err) {
-    // ignore
-  }
+  } catch (_err) {}
+  return undefined;
+};
+
+const getPkgConfigPath = () => {
+  try {
+    const pkgConfigPath = (spawnSync('pkg-config', ['--variable', 'pc_path', 'pkg-config'], { encoding: 'utf8' }).stdout || '').trim();
+    if (pkgConfigPath) {
+      return pkgConfigPath;
+    }
+  } catch (_err) {}
   return undefined;
 };
 
@@ -163,11 +166,8 @@ const pkgConfigPath = () => {
   if (process.platform !== 'win32') {
     return [
       getBrewPkgConfigPath(),
-      process.env.PKG_CONFIG_PATH,
-      '/usr/local/lib/pkgconfig',
-      '/usr/lib/pkgconfig',
-      '/usr/local/libdata/pkgconfig',
-      '/usr/libdata/pkgconfig'
+      getPkgConfigPath(),
+      process.env.PKG_CONFIG_PATH
     ].filter(Boolean).join(':');
   } else {
     return '';

package/lib/output.js

@@ -377,6 +377,35 @@ function withIccProfile (icc, options) {
   return this;
 }
 
+/**
+ * If the input contains gain map metadata, attempt to process the image and gain map separately,
+ * recombining them into a single output image.
+ *
+ * This approach is faster and should produce better results than {@link #withgainmap withGainMap},
+ * however not all operations are supported.
+ *
+ * Only JPEG input and output are supported.
+ * JPEG output options other than `quality` are ignored.
+ *
+ * This feature is experimental and the API may change.
+ *
+ * @since 0.35.0
+ *
+ * @example
+ * const outputWithResizedGainMap = await sharp(inputWithGainMap)
+ *   .keepGainMap()
+ *   .resize({ width: 64 })
+ *   .toBuffer();
+ *
+ * @returns {Sharp}
+ */
+function keepGainMap() {
+  this.options.keepGainMap = true;
+  this.options.withGainMap = false;
+  this.options.keepMetadata |= 0b100000;
+  return this;
+}
+
 /**
  * If the input contains gain map metadata, use it to convert the main image to HDR (High Dynamic Range) before further processing.
  * The input gain map is discarded.
@@ -389,7 +418,7 @@ function withIccProfile (icc, options) {
  * @since 0.35.0
  *
  * @example
- * const outputWithGainMap = await sharp(inputWithGainMap)
+ * const outputWithRegeneratedGainMap = await sharp(inputWithGainMap)
  *   .withGainMap()
  *   .toBuffer();
  *
@@ -397,6 +426,7 @@ function withIccProfile (icc, options) {
  */
 function withGainMap() {
   this.options.withGainMap = true;
+  this.options.keepGainMap = false;
   this.options.colourspace = 'scrgb';
   return this;
 }
@@ -1741,6 +1771,7 @@ module.exports = (Sharp) => {
     withExifMerge,
     keepIccProfile,
     withIccProfile,
+    keepGainMap,
     withGainMap,
     keepXmp,
     withXmp,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@revizly/sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.35.0-revizly22",
+  "version": "0.35.0-revizly24",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://sharp.pixelplumbing.com",
   "contributors": [
@@ -145,24 +145,24 @@
     "semver": "^7.7.4"
   },
   "optionalDependencies": {
-    "@revizly/sharp-libvips-linux-arm64": "1.0.28",
-    "@revizly/sharp-libvips-linux-x64": "1.0.28",
-    "@revizly/sharp-linux-arm64": "0.35.0-revizly16",
-    "@revizly/sharp-linux-x64": "0.35.0-revizly16"
+    "@revizly/sharp-libvips-linux-arm64": "1.0.29",
+    "@revizly/sharp-libvips-linux-x64": "1.0.29",
+    "@revizly/sharp-linux-arm64": "0.35.0-revizly22",
+    "@revizly/sharp-linux-x64": "0.35.0-revizly22"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.4",
+    "@biomejs/biome": "^2.4.8",
     "@cpplint/cli": "^0.1.0",
-    "@emnapi/runtime": "^1.8.1",
-    "@revizly/sharp-libvips-dev": "1.0.28",
+    "@emnapi/runtime": "^1.9.1",
+    "@revizly/sharp-libvips-dev": "1.0.29",
     "@types/node": "*",
-    "emnapi": "^1.8.1",
+    "emnapi": "^1.9.1",
     "exif-reader": "^2.0.3",
     "extract-zip": "^2.0.1",
     "icc": "^3.0.0",
-    "node-addon-api": "^8.5.0",
+    "node-addon-api": "^8.6.0",
     "node-gyp": "^12.2.0",
-    "tar-fs": "^3.1.1",
+    "tar-fs": "^3.1.2",
     "tsd": "^0.33.0"
   },
   "license": "Apache-2.0",
@@ -170,7 +170,7 @@
     "node": ">=20.9.0"
   },
   "config": {
-    "libvips": ">=8.18.0"
+    "libvips": ">=8.18.1"
   },
   "funding": {
     "url": "https://opencollective.com/libvips"

package/src/binding.gyp

@@ -212,7 +212,6 @@
                 '-Oz',
                 '-sALLOW_MEMORY_GROWTH',
                 '-sENVIRONMENT=node',
-                '-sEXPORTED_FUNCTIONS=emnapiInit,_vips_shutdown,_uv_library_shutdown',
                 '-sNODERAWFS',
                 '-sWASM_ASYNC_COMPILATION=0'
               ],

package/src/common.cc

@@ -1164,7 +1164,8 @@ namespace sharp {
     Does this image have a gain map?
   */
   bool HasGainMap(VImage image) {
-    return image.get_typeof("gainmap-data") == VIPS_TYPE_BLOB;
+    return image.get_typeof("gainmap") == VIPS_TYPE_BLOB ||
+      image.get_typeof("gainmap-data") == VIPS_TYPE_BLOB;
   }
 
   /*
@@ -1172,6 +1173,7 @@ namespace sharp {
   */
   VImage RemoveGainMap(VImage image) {
     VImage copy = image.copy();
+    copy.remove("gainmap");
     copy.remove("gainmap-data");
     return copy;
   }

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 < 1)
+#error "libvips version 8.18.1+ 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 {

package/src/metadata.cc

@@ -209,7 +209,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.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
 
@@ -344,9 +344,10 @@ class MetadataWorker : public Napi::AsyncWorker {
         }
         info.Set("comments", comments);
       }
-      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+      Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), info });
     } else {
-      Callback().MakeCallback(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/pipeline.cc

@@ -203,9 +203,11 @@ class PipelineWorker : public Napi::AsyncWorker {
       //  - the width or height parameters are specified;
       //  - gamma correction doesn't need to be applied;
       //  - trimming or pre-resize extract isn't required;
+      //  - gain map processing is not required;
       //  - input colourspace is not specified;
       bool const shouldPreShrink = (targetResizeWidth > 0 || targetResizeHeight > 0) &&
         baton->gamma == 0 && baton->topOffsetPre == -1 && baton->trimThreshold < 0.0 &&
+        !baton->keepGainMap && !baton->withGainMap &&
         baton->colourspacePipeline == VIPS_INTERPRETATION_LAST && !(shouldOrientBefore || shouldRotateBefore);
 
       if (shouldPreShrink) {
@@ -296,12 +298,20 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (baton->input->autoOrient) {
         image = sharp::RemoveExifOrientation(image);
       }
+      VImage gainMap;
+      int gainMapScaleFactor = 1;
       if (sharp::HasGainMap(image)) {
-        if (baton->withGainMap) {
+        if (baton->keepGainMap) {
+          gainMap = image.gainmap();
+          if (image.get_typeof("gainmap-scale-factor") == G_TYPE_INT) {
+            gainMapScaleFactor = image.get_int("gainmap-scale-factor");
+          }
+        } else if (baton->withGainMap) {
           image = image.uhdr2scRGB();
         }
         image = sharp::RemoveGainMap(image);
       } else {
+        baton->keepGainMap = false;
         baton->withGainMap = false;
       }
 
@@ -401,6 +411,11 @@ class PipelineWorker : public Napi::AsyncWorker {
         image = image.resize(1.0 / hshrink, VImage::option()
           ->set("vscale", 1.0 / vshrink)
           ->set("kernel", baton->kernel));
+        if (baton->keepGainMap) {
+          gainMap = gainMap.resize(1.0 / hshrink, VImage::option()
+            ->set("vscale", 1.0 / vshrink)
+            ->set("kernel", baton->kernel));
+        }
       }
 
       image = sharp::StaySequential(image,
@@ -413,14 +428,23 @@ class PipelineWorker : public Napi::AsyncWorker {
           MultiPageUnsupported(nPages, "Rotate");
         }
         image = image.rot(autoRotation);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.rot(autoRotation);
+        }
       }
       // Mirror vertically (up-down) about the x-axis
       if (baton->flip) {
         image = image.flip(VIPS_DIRECTION_VERTICAL);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.flip(VIPS_DIRECTION_VERTICAL);
+        }
       }
       // Mirror horizontally (left-right) about the y-axis
       if (baton->flop != autoFlop) {
         image = image.flip(VIPS_DIRECTION_HORIZONTAL);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.flip(VIPS_DIRECTION_HORIZONTAL);
+        }
       }
       // Rotate post-extract 90-angle
       if (rotation != VIPS_ANGLE_D0) {
@@ -428,6 +452,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           MultiPageUnsupported(nPages, "Rotate");
         }
         image = image.rot(rotation);
+        if (baton->keepGainMap) {
+          gainMap = gainMap.rot(rotation);
+        }
       }
 
       // Join additional color channels to the image
@@ -474,6 +501,12 @@ class PipelineWorker : public Napi::AsyncWorker {
             : image.embed(left, top, width, height, VImage::option()
               ->set("extend", VIPS_EXTEND_BACKGROUND)
               ->set("background", background));
+          if (baton->keepGainMap) {
+            gainMap = gainMap.embed(left / gainMapScaleFactor, top / gainMapScaleFactor,
+              width / gainMapScaleFactor, height / gainMapScaleFactor, VImage::option()
+                ->set("extend", VIPS_EXTEND_BACKGROUND)
+                ->set("background", 0));
+          }
         } else if (baton->canvas == sharp::Canvas::CROP) {
           if (baton->width > inputWidth) {
             baton->width = inputWidth;
@@ -494,12 +527,17 @@ class PipelineWorker : public Napi::AsyncWorker {
               ? sharp::CropMultiPage(image,
                   left, top, width, height, nPages, &targetPageHeight)
               : image.extract_area(left, top, width, height);
+            if (baton->keepGainMap) {
+              gainMap = gainMap.extract_area(left / gainMapScaleFactor, top / gainMapScaleFactor,
+                width / gainMapScaleFactor, height / gainMapScaleFactor);
+            }
           } else {
             int attention_x;
             int attention_y;
 
             // Attention-based or Entropy-based crop
             MultiPageUnsupported(nPages, "Resize strategy");
+            KeepGainMapUnsupported(baton->keepGainMap, "Resize strategy");
             image = sharp::StaySequential(image);
             image = image.smartcrop(baton->width, baton->height, VImage::option()
               ->set("interesting", baton->position == 16 ? VIPS_INTERESTING_ENTROPY : VIPS_INTERESTING_ATTENTION)
@@ -523,6 +561,9 @@ class PipelineWorker : public Napi::AsyncWorker {
         std::vector<double> background;
         std::tie(image, background) = sharp::ApplyAlpha(image, baton->rotationBackground, shouldPremultiplyAlpha);
         image = image.rotate(baton->rotationAngle, VImage::option()->set("background", background));
+        if (baton->keepGainMap) {
+          gainMap = gainMap.rotate(baton->rotationAngle, VImage::option()->set("background", 0));
+        }
       }
 
       // Post extraction
@@ -531,18 +572,23 @@ class PipelineWorker : public Napi::AsyncWorker {
           image = sharp::CropMultiPage(image,
             baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost,
             nPages, &targetPageHeight);
-
           // heightPost is used in the info object, so update to reflect the number of pages
           baton->heightPost *= nPages;
         } else {
           image = image.extract_area(
             baton->leftOffsetPost, baton->topOffsetPost, baton->widthPost, baton->heightPost);
+          if (baton->keepGainMap) {
+            gainMap = gainMap.extract_area(baton->leftOffsetPost / gainMapScaleFactor,
+              baton->topOffsetPost / gainMapScaleFactor, baton->widthPost / gainMapScaleFactor,
+              baton->heightPost / gainMapScaleFactor);
+          }
         }
       }
 
       // Affine transform
       if (!baton->affineMatrix.empty()) {
         MultiPageUnsupported(nPages, "Affine");
+        KeepGainMapUnsupported(baton->keepGainMap, "Affine");
         image = sharp::StaySequential(image);
         std::vector<double> background;
         std::tie(image, background) = sharp::ApplyAlpha(image, baton->affineBackground, shouldPremultiplyAlpha);
@@ -573,6 +619,12 @@ class PipelineWorker : public Napi::AsyncWorker {
                 baton->extendWith, background, nPages, &targetPageHeight)
             : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
                 VImage::option()->set("extend", baton->extendWith)->set("background", background));
+          if (baton->keepGainMap) {
+            gainMap = gainMap.embed(baton->extendLeft / gainMapScaleFactor, baton->extendTop / gainMapScaleFactor,
+              baton->width / gainMapScaleFactor, baton->height / gainMapScaleFactor, VImage::option()
+                ->set("extend", baton->extendWith)
+                ->set("background", 0));
+          }
         } else {
           std::vector<double> ignoredBackground(1);
           image = sharp::StaySequential(image);
@@ -582,6 +634,12 @@ class PipelineWorker : public Napi::AsyncWorker {
                 baton->extendWith, ignoredBackground, nPages, &targetPageHeight)
             : image.embed(baton->extendLeft, baton->extendTop, baton->width, baton->height,
                 VImage::option()->set("extend", baton->extendWith));
+          if (baton->keepGainMap) {
+            gainMap = gainMap.embed(baton->extendLeft / gainMapScaleFactor, baton->extendTop / gainMapScaleFactor,
+              baton->width / gainMapScaleFactor, baton->height / gainMapScaleFactor, VImage::option()
+                ->set("extend", baton->extendWith)
+                ->set("background", 0));
+          }
         }
       }
       // Median - must happen before blurring, due to the utility of blurring after thresholding
@@ -608,6 +666,9 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Blur
       if (shouldBlur) {
         image = sharp::Blur(image, baton->blurSigma, baton->precision, baton->minAmpl);
+        if (baton->keepGainMap) {
+          gainMap = sharp::Blur(gainMap, baton->blurSigma, baton->precision, baton->minAmpl);
+        }
       }
 
       // Unflatten the image
@@ -617,6 +678,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Convolve
       if (shouldConv) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Convolve");
         image = sharp::Convolve(image,
           baton->convKernelWidth, baton->convKernelHeight,
           baton->convKernelScale, baton->convKernelOffset,
@@ -625,11 +687,13 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Recomb
       if (!baton->recombMatrix.empty()) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Recomb");
         image = sharp::Recomb(image, baton->recombMatrix);
       }
 
       // Modulate
       if (baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0 || baton->lightness != 0.0) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Modulate");
         image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue, baton->lightness);
       }
 
@@ -647,6 +711,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Composite
       if (shouldComposite) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Composite");
         std::vector<VImage> images = { image };
         std::vector<int> modes, xs, ys;
         for (Composite *composite : baton->composite) {
@@ -759,18 +824,21 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Apply normalisation - stretch luminance to cover full dynamic range
       if (baton->normalise) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Normalise");
         image = sharp::StaySequential(image);
         image = sharp::Normalise(image, baton->normaliseLower, baton->normaliseUpper);
       }
 
       // Apply contrast limiting adaptive histogram equalization (CLAHE)
       if (baton->claheWidth != 0 && baton->claheHeight != 0) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Clahe");
         image = sharp::StaySequential(image);
         image = sharp::Clahe(image, baton->claheWidth, baton->claheHeight, baton->claheMaxSlope);
       }
 
       // Apply bitwise boolean operation between images
       if (baton->boolean != nullptr) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Boolean");
         VImage booleanImage;
         sharp::ImageType booleanImageType = sharp::ImageType::UNKNOWN;
         baton->boolean->access = access;
@@ -813,6 +881,7 @@ class PipelineWorker : public Napi::AsyncWorker {
 
       // Extract channel
       if (baton->extractChannel > -1) {
+        KeepGainMapUnsupported(baton->keepGainMap, "Extract channel");
         if (baton->extractChannel >= image.bands()) {
           if (baton->extractChannel == 3 && image.has_alpha()) {
             baton->extractChannel = image.bands() - 1;
@@ -847,6 +916,9 @@ class PipelineWorker : public Napi::AsyncWorker {
       // Negate the colours in the image
       if (baton->negate) {
         image = sharp::Negate(image, baton->negateAlpha);
+        if (baton->keepGainMap) {
+          gainMap = sharp::Negate(gainMap, false);
+        }
       }
 
       // Override EXIF Orientation tag
@@ -893,18 +965,27 @@ class PipelineWorker : public Napi::AsyncWorker {
         if (baton->formatOut == "jpeg" || (baton->formatOut == "input" && inputImageType == sharp::ImageType::JPEG)) {
           // Write JPEG to buffer
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
-          VipsArea *area = reinterpret_cast<VipsArea*>(image.jpegsave_buffer(VImage::option()
-            ->set("keep", baton->keepMetadata)
-            ->set("Q", baton->jpegQuality)
-            ->set("interlace", baton->jpegProgressive)
-            ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
-              ? VIPS_FOREIGN_SUBSAMPLE_OFF
-              : VIPS_FOREIGN_SUBSAMPLE_ON)
-            ->set("trellis_quant", baton->jpegTrellisQuantisation)
-            ->set("quant_table", baton->jpegQuantisationTable)
-            ->set("overshoot_deringing", baton->jpegOvershootDeringing)
-            ->set("optimize_scans", baton->jpegOptimiseScans)
-            ->set("optimize_coding", baton->jpegOptimiseCoding)));
+          VipsArea *area;
+          if (baton->keepGainMap) {
+            image = ReattachGainMap(image, gainMap, baton);
+            area = reinterpret_cast<VipsArea*>(image.uhdrsave_buffer(VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("gainmap_scale_factor", gainMapScaleFactor)));
+          } else {
+            area = reinterpret_cast<VipsArea*>(image.jpegsave_buffer(VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("interlace", baton->jpegProgressive)
+              ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
+                ? VIPS_FOREIGN_SUBSAMPLE_OFF
+                : VIPS_FOREIGN_SUBSAMPLE_ON)
+              ->set("trellis_quant", baton->jpegTrellisQuantisation)
+              ->set("quant_table", baton->jpegQuantisationTable)
+              ->set("overshoot_deringing", baton->jpegOvershootDeringing)
+              ->set("optimize_scans", baton->jpegOptimiseScans)
+              ->set("optimize_coding", baton->jpegOptimiseCoding)));
+          }
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
           area->free_fn = nullptr;
@@ -1121,18 +1202,26 @@ class PipelineWorker : public Napi::AsyncWorker {
           (willMatchInput && inputImageType == sharp::ImageType::JPEG)) {
           // Write JPEG to file
           sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
-          image.jpegsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
-            ->set("keep", baton->keepMetadata)
-            ->set("Q", baton->jpegQuality)
-            ->set("interlace", baton->jpegProgressive)
-            ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
-              ? VIPS_FOREIGN_SUBSAMPLE_OFF
-              : VIPS_FOREIGN_SUBSAMPLE_ON)
-            ->set("trellis_quant", baton->jpegTrellisQuantisation)
-            ->set("quant_table", baton->jpegQuantisationTable)
-            ->set("overshoot_deringing", baton->jpegOvershootDeringing)
-            ->set("optimize_scans", baton->jpegOptimiseScans)
-            ->set("optimize_coding", baton->jpegOptimiseCoding));
+          if (baton->keepGainMap) {
+            image = ReattachGainMap(image, gainMap, baton);
+            image.uhdrsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("gainmap_scale_factor", gainMapScaleFactor));
+          } else {
+            image.jpegsave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+              ->set("keep", baton->keepMetadata)
+              ->set("Q", baton->jpegQuality)
+              ->set("interlace", baton->jpegProgressive)
+              ->set("subsample_mode", baton->jpegChromaSubsampling == "4:4:4"
+                ? VIPS_FOREIGN_SUBSAMPLE_OFF
+                : VIPS_FOREIGN_SUBSAMPLE_ON)
+              ->set("trellis_quant", baton->jpegTrellisQuantisation)
+              ->set("quant_table", baton->jpegQuantisationTable)
+              ->set("overshoot_deringing", baton->jpegOvershootDeringing)
+              ->set("optimize_scans", baton->jpegOptimiseScans)
+              ->set("optimize_coding", baton->jpegOptimiseCoding));
+          }
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
         } else if (baton->formatOut == "jp2" || (mightMatchInput && isJp2) ||
@@ -1301,7 +1390,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       if (baton->errUseWarning) {
         (baton->err).append("\n").append(warning);
       } else {
-        debuglog.MakeCallback(Receiver().Value(), { Napi::String::New(env, warning) });
+        debuglog.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { Napi::String::New(env, warning) });
       }
       warning = sharp::VipsWarningPop();
     }
@@ -1350,17 +1439,15 @@ class PipelineWorker : public Napi::AsyncWorker {
         info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));
         if (baton->typedArrayOut) {
           // ECMAScript ArrayBuffer with Uint8Array view
-          Napi::ArrayBuffer ab = Napi::ArrayBuffer::New(env, baton->bufferOutLength);
-          memcpy(ab.Data(), baton->bufferOut, baton->bufferOutLength);
+          Napi::TypedArrayOf<uint8_t> data = Napi::Buffer<char>::Copy(env,
+            static_cast<char*>(baton->bufferOut), baton->bufferOutLength);
           sharp::FreeCallback(static_cast<char*>(baton->bufferOut), nullptr);
-          Napi::TypedArrayOf<uint8_t> data = Napi::TypedArrayOf<uint8_t>::New(env,
-            baton->bufferOutLength, ab, 0, napi_uint8_array);
-          Callback().MakeCallback(Receiver().Value(), { env.Null(), data, info });
+          Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), data, info });
         } else {
           // Node.js Buffer
           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().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), data, info });
         }
       } else {
         // Add file size to info
@@ -1371,10 +1458,11 @@ class PipelineWorker : public Napi::AsyncWorker {
             info.Set("size", size);
           } catch (...) {}
         }
-        Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
+        Callback().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), info });
       }
     } else {
-      Callback().MakeCallback(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
@@ -1395,7 +1483,7 @@ class PipelineWorker : public Napi::AsyncWorker {
     // Decrement processing task counter
     sharp::counterProcess--;
     Napi::Number queueLength = Napi::Number::New(env, static_cast<int>(sharp::counterQueue));
-    queueListener.MakeCallback(Receiver().Value(), { queueLength });
+    queueListener.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { queueLength });
   }
 
  private:
@@ -1409,6 +1497,12 @@ class PipelineWorker : public Napi::AsyncWorker {
     }
   }
 
+  void KeepGainMapUnsupported(bool const keepGainMap, std::string op) {
+    if (keepGainMap) {
+      throw std::runtime_error(op + " is not supported when keeping gain maps");
+    }
+  }
+
   /*
     Calculate the angle of rotation and need-to-flip for the given Exif orientation
     By default, returns zero, i.e. no rotation.
@@ -1527,6 +1621,21 @@ class PipelineWorker : public Napi::AsyncWorker {
     return options;
   }
 
+  VImage ReattachGainMap(VImage image, VImage gainMap, PipelineBaton *baton) {
+    VipsArea *gainMapJpeg = reinterpret_cast<VipsArea*>(gainMap.jpegsave_buffer(VImage::option()
+      ->set("keep", FALSE)
+      ->set("Q", baton->jpegQuality)
+      ->set("subsample_mode", VIPS_FOREIGN_SUBSAMPLE_OFF)
+      ->set("trellis_quant", baton->jpegTrellisQuantisation)
+      ->set("quant_table", baton->jpegQuantisationTable)
+      ->set("overshoot_deringing", baton->jpegOvershootDeringing)
+      ->set("optimize_coding", baton->jpegOptimiseCoding)));
+    image = image.copy();
+    image.set("gainmap-data", reinterpret_cast<VipsCallbackFn>(vips_area_free_cb),
+      gainMapJpeg->data, gainMapJpeg->length);
+    return image;
+  }
+
   /*
     Clear all thread-local data.
   */
@@ -1728,6 +1837,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   }
   baton->withExifMerge = sharp::AttrAsBool(options, "withExifMerge");
   baton->withXmp = sharp::AttrAsStr(options, "withXmp");
+  baton->keepGainMap = sharp::AttrAsBool(options, "keepGainMap");
   baton->withGainMap = sharp::AttrAsBool(options, "withGainMap");
   baton->timeoutSeconds = sharp::AttrAsUint32(options, "timeoutSeconds");
   baton->loop = sharp::AttrAsUint32(options, "loop");
@@ -1833,7 +1943,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
 
   // Increment queued task counter
   Napi::Number queueLength = Napi::Number::New(info.Env(), static_cast<int>(++sharp::counterQueue));
-  queueListener.MakeCallback(info.This(), { queueLength });
+  queueListener.SHARP_CALLBACK_FN_NAME(info.This(), { queueLength });
 
   return info.Env().Undefined();
 }

package/src/pipeline.h

@@ -213,6 +213,7 @@ struct PipelineBaton {
   bool withExifMerge;
   std::string withXmp;
   bool withGainMap;
+  bool keepGainMap;
   int timeoutSeconds;
   std::vector<double> convKernel;
   int convKernelWidth;
@@ -391,6 +392,7 @@ struct PipelineBaton {
     withMetadataDensity(0.0),
     withExifMerge(true),
     withGainMap(false),
+    keepGainMap(false),
     timeoutSeconds(0),
     convKernelWidth(0),
     convKernelHeight(0),

package/src/stats.cc

@@ -109,7 +109,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.SHARP_CALLBACK_FN_NAME(Receiver().Value(), { Napi::String::New(env, warning) });
       warning = sharp::VipsWarningPop();
     }
     if (baton->err.empty()) {
@@ -143,9 +143,10 @@ 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().SHARP_CALLBACK_FN_NAME(Receiver().Value(), { env.Null(), info });
     } else {
-      Callback().MakeCallback(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;