Add hasAlpha property to output info #4500

Author: lovell

.github/workflows/ci.yml

@@ -312,7 +312,7 @@ jobs:
     needs: lint
     name: "build-wasm32 [package]"
     runs-on: ubuntu-24.04
-    container: "emscripten/emsdk:6.0.0"
+    container: "emscripten/emsdk:6.0.1"
     steps:
       - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:

docs/src/content/docs/changelog/v0.35.3.md

@@ -5,6 +5,11 @@ slug: changelog/v0.35.3
 
 * Tighten verification of `text` dimensions, TIFF tile dimensions and `extend` values.
 
+* Improve code bundler support by resolving path to libvips binary.
+
+* Add `hasAlpha` property to output `info`.
+  [#4500](https://github.com/lovell/sharp/issues/4500)
+
 * Bound `clahe` width and height to avoid signed overflow.
   [#4551]((https://github.com/lovell/sharp/pull/4551)
   [@metsw24-max](https://github.com/metsw24-max)
@@ -32,3 +37,7 @@ slug: changelog/v0.35.3
 * Tighten recomb and affine matrix verification.
   [#4560](https://github.com/lovell/sharp/pull/4560)
   [@chatman-media](https://github.com/chatman-media)
+
+* Verify cache memory limit to avoid overflow.
+  [#4561](https://github.com/lovell/sharp/pull/4561)
+  [@metsw24-max](https://github.com/metsw24-max)

lib/index.d.ts

@@ -1783,6 +1783,8 @@ declare namespace sharp {
         channels: Channels;
         /** indicating if premultiplication was used */
         premultiplied: boolean;
+        /** Indicates if the output image has an alpha channel */
+        hasAlpha: boolean;
         /** Only defined when using a crop strategy */
         cropOffsetLeft?: number | undefined;
         /** Only defined when using a crop strategy */

src/pipeline.cc

@@ -944,6 +944,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         baton->pageHeightOut = image.get_int(VIPS_META_PAGE_HEIGHT);
         baton->pagesOut = image.get_int(VIPS_META_N_PAGES);
       }
+      baton->hasAlphaOut = image.has_alpha();
 
       // Output
       sharp::SetTimeout(image, baton->timeoutSeconds);
@@ -983,6 +984,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           } else {
             baton->channels = std::min(baton->channels, 3);
           }
+          baton->hasAlphaOut = false;
         } else if (baton->formatOut == "jp2" || (baton->formatOut == "input"
           && inputImageType == sharp::ImageType::JP2)) {
           // Write JP2 to Buffer
@@ -1065,6 +1067,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
             sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
             baton->channels = std::min(baton->channels, 3);
+            baton->hasAlphaOut = false;
           }
           // Cast pixel values to float, if required
           if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
@@ -1124,6 +1127,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           area->free_fn = nullptr;
           vips_area_unref(area);
           baton->formatOut = "dz";
+          if (baton->tileFormat == "jpeg") {
+            baton->hasAlphaOut = false;
+          }
         } else if (baton->formatOut == "jxl" ||
           (baton->formatOut == "input" && inputImageType == sharp::ImageType::JXL)) {
           // Write JXL to buffer
@@ -1211,6 +1217,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           }
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
+          baton->hasAlphaOut = false;
         } else if (baton->formatOut == "jp2" || (mightMatchInput && isJp2) ||
           (willMatchInput && (inputImageType == sharp::ImageType::JP2))) {
           // Write JP2 to file
@@ -1277,6 +1284,7 @@ class PipelineWorker : public Napi::AsyncWorker {
           if (baton->tiffCompression == VIPS_FOREIGN_TIFF_COMPRESSION_JPEG) {
             sharp::AssertImageTypeDimensions(image, sharp::ImageType::JPEG);
             baton->channels = std::min(baton->channels, 3);
+            baton->hasAlphaOut = false;
           }
           // Cast pixel values to float, if required
           if (baton->tiffPredictor == VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT) {
@@ -1337,6 +1345,9 @@ class PipelineWorker : public Napi::AsyncWorker {
           vips::VOption *options = BuildOptionsDZ(baton);
           image.dzsave(const_cast<char*>(baton->fileOut.data()), options);
           baton->formatOut = "dz";
+          if (baton->tileFormat == "jpeg") {
+            baton->hasAlphaOut = false;
+          }
         } else if (baton->formatOut == "v" || (mightMatchInput && isV) ||
           (willMatchInput && inputImageType == sharp::ImageType::VIPS)) {
           // Write V to file
@@ -1421,6 +1432,7 @@ class PipelineWorker : public Napi::AsyncWorker {
         info.Set("pageHeight", static_cast<int32_t>(baton->pageHeightOut));
         info.Set("pages", static_cast<int32_t>(baton->pagesOut));
       }
+      info.Set("hasAlpha", baton->hasAlphaOut);
 
       if (baton->bufferOutLength > 0) {
         info.Set("size", static_cast<uint32_t>(baton->bufferOutLength));

src/pipeline.h

@@ -49,6 +49,7 @@ struct PipelineBaton {
   int pageHeightOut;
   int pagesOut;
   bool typedArrayOut;
+  bool hasAlphaOut;
   std::vector<Composite *> composite;
   std::vector<sharp::InputDescriptor *> joinChannelIn;
   int topOffsetPre;
@@ -249,6 +250,7 @@ struct PipelineBaton {
     pageHeightOut(0),
     pagesOut(0),
     typedArrayOut(false),
+    hasAlphaOut(false),
     topOffsetPre(-1),
     topOffsetPost(-1),
     channels(0),

test/unit/io.js

@@ -25,7 +25,7 @@ suite('Input/output', () => {
   });
 
   test('Read from File and write to Stream', async (t) => {
-    t.plan(5);
+    t.plan(6);
     const writable = createWriteStream(outputJpg);
     const closed = new Promise((resolve, reject) => {
       writable.once('close', resolve);
@@ -39,11 +39,12 @@ suite('Input/output', () => {
     t.assert.strictEqual('jpeg', info.format);
     t.assert.strictEqual(320, info.width);
     t.assert.strictEqual(240, info.height);
+    t.assert.strictEqual(false, info.hasAlpha);
     await fs.rm(outputJpg);
   });
 
   test('Read from Buffer and write to Stream', async (t) => {
-    t.plan(5);
+    t.plan(6);
     const inputJpgBuffer = await fs.readFile(fixtures.inputJpg);
     const writable = createWriteStream(outputJpg);
     const closed = new Promise((resolve, reject) => {
@@ -58,26 +59,28 @@ suite('Input/output', () => {
     t.assert.strictEqual('jpeg', info.format);
     t.assert.strictEqual(320, info.width);
     t.assert.strictEqual(240, info.height);
+    t.assert.strictEqual(false, info.hasAlpha);
     await fs.rm(outputJpg);
   });
 
   test('Read from Stream and write to File via callback', (t, done) => {
-    t.plan(4);
+    t.plan(5);
     const readable = createReadStream(fixtures.inputJpg);
     const pipeline = sharp().resize(320, 240).toFile(outputJpg, async (err, info) => {
       if (err) throw err;
       t.assert.strictEqual(true, info.size > 0);
       t.assert.strictEqual('jpeg', info.format);
       t.assert.strictEqual(320, info.width);
       t.assert.strictEqual(240, info.height);
+      t.assert.strictEqual(false, info.hasAlpha);
       await fs.rm(outputJpg);
       done();
     });
     readable.pipe(pipeline);
   });
 
   test('Read from Stream and write to Buffer via callback', (t, done) => {
-    t.plan(5);
+    t.plan(6);
     const readable = createReadStream(fixtures.inputJpg);
     const pipeline = sharp().resize(320, 240).toBuffer((err, data, info) => {
       if (err) throw err;
@@ -86,20 +89,22 @@ suite('Input/output', () => {
       t.assert.strictEqual('jpeg', info.format);
       t.assert.strictEqual(320, info.width);
       t.assert.strictEqual(240, info.height);
+      t.assert.strictEqual(false, info.hasAlpha);
       done();
     });
     readable.pipe(pipeline);
   });
 
   test('Read from File and write to Buffer via callback', (t, done) => {
-    t.plan(6);
+    t.plan(7);
     sharp(fixtures.inputJpg).resize(320, 240).toBuffer((err, data, info) => {
       t.assert.strictEqual(err, null);
       t.assert.strictEqual(true, data.length > 0);
       t.assert.strictEqual(data.length, info.size);
       t.assert.strictEqual('jpeg', info.format);
       t.assert.strictEqual(320, info.width);
       t.assert.strictEqual(240, info.height);
+      t.assert.strictEqual(false, info.hasAlpha);
       done();
     });
   });
@@ -126,7 +131,7 @@ suite('Input/output', () => {
   });
 
   test('Read from Stream and write to Buffer via Promise resolved with Object', async (t) => {
-    t.plan(8);
+    t.plan(9);
     const pipeline = sharp().resize(1, 1);
     createReadStream(fixtures.inputJpg).pipe(pipeline);
     const object = await pipeline.toBuffer({ resolveWithObject: true });
@@ -136,6 +141,7 @@ suite('Input/output', () => {
     t.assert.strictEqual(1, object.info.width);
     t.assert.strictEqual(1, object.info.height);
     t.assert.strictEqual(3, object.info.channels);
+    t.assert.strictEqual(false, object.info.hasAlpha);
     t.assert.strictEqual(true, object.data instanceof Buffer);
     t.assert.strictEqual(true, object.data.length > 0);
   });
@@ -150,7 +156,7 @@ suite('Input/output', () => {
   });
 
   test('Read from File and write to Buffer via Promise resolved with Object', async (t) => {
-    t.plan(8);
+    t.plan(9);
     const object = await sharp(fixtures.inputJpg)
       .resize(1, 1)
       .toBuffer({ resolveWithObject: true });
@@ -160,12 +166,13 @@ suite('Input/output', () => {
     t.assert.strictEqual(1, object.info.width);
     t.assert.strictEqual(1, object.info.height);
     t.assert.strictEqual(3, object.info.channels);
+    t.assert.strictEqual(false, object.info.hasAlpha);
     t.assert.strictEqual(true, object.data instanceof Buffer);
     t.assert.strictEqual(true, object.data.length > 0);
   });
 
   test('Read from Stream and write to Stream', async (t) => {
-    t.plan(5);
+    t.plan(6);
     const readable = createReadStream(fixtures.inputJpg);
     const writable = createWriteStream(outputJpg);
     const closed = new Promise((resolve, reject) => {
@@ -181,6 +188,7 @@ suite('Input/output', () => {
     t.assert.strictEqual('jpeg', info.format);
     t.assert.strictEqual(320, info.width);
     t.assert.strictEqual(240, info.height);
+    t.assert.strictEqual(false, info.hasAlpha);
     await fs.rm(outputJpg);
   });
 
@@ -256,7 +264,7 @@ suite('Input/output', () => {
   });
 
   test('Stream should emit info event', async (t) => {
-    t.plan(4);
+    t.plan(5);
     const readable = createReadStream(fixtures.inputJpg);
     const writable = createWriteStream(outputJpg);
     const pipeline = sharp().resize(320, 240);
@@ -266,6 +274,7 @@ suite('Input/output', () => {
         t.assert.strictEqual(320, info.width);
         t.assert.strictEqual(240, info.height);
         t.assert.strictEqual(3, info.channels);
+        t.assert.strictEqual(false, info.hasAlpha);
         resolve();
       });
     });
@@ -593,43 +602,46 @@ suite('Input/output', () => {
     });
 
     test('Match PNG input', async (t) => {
-      t.plan(4);
-      const info = await sharp(fixtures.inputPng)
+      t.plan(5);
+      const info = await sharp(fixtures.inputPngRGBWithAlpha)
         .resize(320, 80)
         .toFile(outputZoinks);
       t.assert.strictEqual(true, info.size > 0);
       t.assert.strictEqual('png', info.format);
       t.assert.strictEqual(320, info.width);
       t.assert.strictEqual(80, info.height);
+      t.assert.strictEqual(true, info.hasAlpha);
       await fs.rm(outputZoinks);
     });
 
     test('Match WebP input', async (t) => {
-      t.plan(4);
-      const info = await sharp(fixtures.inputWebP)
+      t.plan(5);
+      const info = await sharp(fixtures.inputWebPWithTransparency)
         .resize(320, 80)
         .toFile(outputZoinks);
       t.assert.strictEqual(true, info.size > 0);
       t.assert.strictEqual('webp', info.format);
       t.assert.strictEqual(320, info.width);
       t.assert.strictEqual(80, info.height);
+      t.assert.strictEqual(true, info.hasAlpha);
       await fs.rm(outputZoinks);
     });
 
     test('Match TIFF input', async (t) => {
-      t.plan(4);
+      t.plan(5);
       const info = await sharp(fixtures.inputTiff)
         .resize(320, 80)
         .toFile(outputZoinks);
       t.assert.strictEqual(true, info.size > 0);
       t.assert.strictEqual('tiff', info.format);
       t.assert.strictEqual(320, info.width);
       t.assert.strictEqual(80, info.height);
+      t.assert.strictEqual(false, info.hasAlpha);
       await fs.rm(outputZoinks);
     });
 
     test('Force JPEG format for PNG input', async (t) => {
-      t.plan(4);
+      t.plan(5);
       const info = await sharp(fixtures.inputPng)
         .resize(320, 80)
         .jpeg()
@@ -638,19 +650,21 @@ suite('Input/output', () => {
       t.assert.strictEqual('jpeg', info.format);
       t.assert.strictEqual(320, info.width);
       t.assert.strictEqual(80, info.height);
+      t.assert.strictEqual(false, info.hasAlpha);
       await fs.rm(outputZoinks);
     });
   });
 
   test('Input and output formats match when not forcing', async (t) => {
-    t.plan(3);
+    t.plan(4);
     const { info } = await sharp(fixtures.inputJpg)
       .resize(320, 240)
       .png({ compressionLevel: 1, force: false })
       .toBuffer({ resolveWithObject: true });
     t.assert.strictEqual('jpeg', info.format);
     t.assert.strictEqual(320, info.width);
     t.assert.strictEqual(240, info.height);
+    t.assert.strictEqual(false, info.hasAlpha);
   });
 
   test('Can force output format with output chaining', async (t) => {
@@ -686,14 +700,15 @@ suite('Input/output', () => {
   });
 
   test('Load Vips V file', async (t) => {
-    t.plan(4);
+    t.plan(5);
     const { data, info } = await sharp(fixtures.inputV)
       .jpeg()
       .toBuffer({ resolveWithObject: true });
     t.assert.strictEqual(true, data.length > 0);
     t.assert.strictEqual('jpeg', info.format);
     t.assert.strictEqual(70, info.width);
     t.assert.strictEqual(60, info.height);
+    t.assert.strictEqual(false, info.hasAlpha);
     await fixtures.assertSimilar(fixtures.expected('vfile.jpg'), data);
   });
 
@@ -1201,7 +1216,7 @@ suite('Input/output', () => {
   });
 
   test('Info event data', async (t) => {
-    t.plan(4);
+    t.plan(5);
     const readable = createReadStream(fixtures.inputJPGBig);
     const inPipeline = sharp()
       .resize(840, 472)
@@ -1210,6 +1225,7 @@ suite('Input/output', () => {
         t.assert.strictEqual(840, info.width);
         t.assert.strictEqual(472, info.height);
         t.assert.strictEqual(3, info.channels);
+        t.assert.strictEqual(false, info.hasAlpha);
       });
     const badPipeline = sharp({ raw: { width: 840, height: 500, channels: 3 } }).toFormat('jpeg');
     readable.pipe(inPipeline).pipe(badPipeline);
@@ -1255,7 +1271,7 @@ suite('Input/output', () => {
       .resize({ width: 8, height: 8 })
       .toUint8Array();
 
-    t.plan(isMarkedAsUntransferable ? 12 : 11);
+    t.plan(isMarkedAsUntransferable ? 13 : 12);
     t.assert.strictEqual(data instanceof Uint8Array, true);
     if (isMarkedAsUntransferable) {
       t.assert.strictEqual(isMarkedAsUntransferable(data.buffer), false);
@@ -1267,6 +1283,7 @@ suite('Input/output', () => {
     t.assert.strictEqual(data.byteLength, info.size);
     t.assert.strictEqual(data[0], 0xFF);
     t.assert.strictEqual(data[1], 0xD8);
+    t.assert.strictEqual(info.hasAlpha, false);
 
     const metadata = await sharp(data).metadata();
     t.assert.strictEqual(metadata.format, 'jpeg');