composite: the fast path for normal mode with an opacity too

Normal mode with an opacity went through __blend__, per channel in
floats with the blend function called for each. It is source over with
the source alpha scaled by the opacity: the fast path's formula. The
fast path also indexes by offsets incremented per pixel and copies
bytes instead of 32-bit words, which was no faster.

A 1100x680 layer (two thirds at alpha 150) onto an opaque image, median
of 100 runs: opacity 0.85 12.6 -> 7.6 ms, opacity 1 9.4 -> 7.6 ms; an
opaque layer 4.4 -> 4.2 ms. The results are byte-identical to __blend__
on random pixels at random opacities; at exact halves (opacity 0.5 of
opaque pixels) they now round like the fast path did, by 1 at most.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BsU2GDnECphmYTjLB5UeZv

Author: claude

src/image.ts

@@ -1287,30 +1287,30 @@ export class Image {
         const blend = BLEND_MODES[mode];
         if (!blend || !Object.prototype.hasOwnProperty.call(BLEND_MODES, mode))
             throw new RangeError(`Invalid blend mode: ${mode}`);
-        if (opacity !== 1 || mode !== 'normal') return this.__blend__(source, x, y, opacity, blend);
+        if (mode !== 'normal') return this.__blend__(source, x, y, opacity, blend);
+        if (opacity === 0) return this;
 
         const left = Math.max(0, x), top = Math.max(0, y);
         const right = Math.min(this.width, x + source.width), bottom = Math.min(this.height, y + source.height);
         const dst = this.bitmap, src = source.bitmap;
-        // whole pixels are copied through 32-bit views
-        const dst32 = new Uint32Array(dst.buffer, dst.byteOffset, dst.length >> 2);
-        const src32 = new Uint32Array(src.buffer, src.byteOffset, src.length >> 2);
 
         for (let row = top; row < bottom; row++) {
-            for (let column = left; column < right; column++) {
-                const sp = (row - y) * source.width + column - x, s = 4 * sp;
+            for (let column = left, s = 4 * ((row - y) * source.width + left - x), d = 4 * (row * this.width + left); column < right; column++, s += 4, d += 4) {
                 const sa = src[s + 3];
                 if (sa === 0) continue;
 
-                const dp = row * this.width + column, d = 4 * dp;
                 const da = dst[d + 3];
-                if (sa === 255 || da === 0) {
-                    dst32[dp] = src32[sp];
+                if ((sa === 255 && opacity === 1) || da === 0) {
+                    dst[d] = src[s];
+                    dst[d + 1] = src[s + 1];
+                    dst[d + 2] = src[s + 2];
+                    dst[d + 3] = sa * opacity;
                     continue;
                 }
 
-                // source over with straight alpha, the clamped bitmap rounds on assignment
-                const fa = sa / 255, ba = da / 255 * (1 - fa);
+                // source over with straight alpha (the source's scaled by the opacity), the clamped bitmap rounds on
+                // assignment
+                const fa = sa / 255 * opacity, ba = da / 255 * (1 - fa);
                 const a = fa + ba;
                 dst[d] = (src[s] * fa + dst[d] * ba) / a;
                 dst[d + 1] = (src[s + 1] * fa + dst[d + 1] * ba) / a;

tests/regressions.js

@@ -441,6 +441,18 @@ const rgba = (image, x, y) => Image.colorToRGBA(image.getPixelAt(x, y));
         assert(rgba(base.clone().composite(top, 0, 0, {mode: 'multiply'}), 0, 0).join() === '64,128,192,255', 'blend over transparency');
         assert(Buffer.from(base.clone().composite(top, 0, 0, {mode: 'normal', opacity: 1}).bitmap).equals(Buffer.from(base.clone().composite(top).bitmap)), 'normal mode');
 
+        // normal mode with an opacity (source over with the source alpha scaled) matches the general compositing model,
+        // also for translucent pixels, off the edges
+        let seed = 3;
+        const random = () => (seed = Math.imul(seed, 1103515245) + 12345 >>> 0) / 2 ** 32;
+        const pixel = () => Image.rgbaToColor(random() * 256 | 0, random() * 256 | 0, random() * 256 | 0, [0, 255, random() * 256 | 0][random() * 3 | 0]);
+        const backdrop = new Image(24, 16).fill(pixel), source = new Image(16, 24).fill(pixel);
+        for (const opacity of [0.3, 0.85, 0.999]) {
+            const expected = backdrop.clone().__blend__(source, 12, -4, opacity, (_, s) => s).bitmap;
+            const actual = backdrop.clone().composite(source, 12, -4, {opacity}).bitmap;
+            assert(actual.every((v, i) => Math.abs(v - expected[i]) <= 1), `normal mode with opacity ${opacity} differs from the compositing model`);
+        }
+
         let threw = 0;
         for (const options of [{mode: 'foo'}, {mode: 'toString'}, {opacity: 2}, {opacity: NaN}])
             try { base.clone().composite(top, 0, 0, options); } catch { threw++; }