JXL: faster patch search

The connected components outside the background are traversed with a
growing Int32Array stack of pixel indices instead of a JS array of
coordinate pairs, popped in the same order (the first background pixel
reached stays the reference): the same files (20 encodes at efforts
0-2). A 1920x1080 photo's search, which finds no patches, takes about
550 instead of 750 ms here (most pixels form one large component).

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

Author: matmen

CHANGELOG.md

@@ -24,6 +24,8 @@
   instead of 640 ms lossy and 328 ms instead of 671 ms lossless, a 5120x2880 one in 568 ms instead of 1121 ms and
   487 ms instead of 1122 ms. Lossy frames no longer keep the coefficients of the whole frame (about 100 MB at 4K): each
   group is rendered once its passes are read.
+- `encodeJXL({ quality, effort: 2 })` searches patches about 30% faster (the connected components with a typed stack of
+  pixel indices instead of an array of coordinates, in the same order): the same files.
 - AVIF decoding uses worker threads (`DecodeOptions.threads`) from 4 megapixels on: the conversion to RGB runs in
   bands of rows (started at the beginning, the threads load while the AV1 image is decoded) and the tiles of grids are
   decoded in parallel, with the same pixels. A 3840x2160 4:2:0 image decodes in 355 ms instead of 466 ms, a 6400x2880

src/codecs/jxl/patches-enc.ts

@@ -122,16 +122,18 @@ function candidates(planes: Float32Array[], stride: number, width: number, heigh
     }
 
     // small connected components outside the background, bordered by one background color
+    // (a stack of pixel indices, grown as needed: a pixel is pushed by each neighbor reaching it before it's visited)
     const visited = new Uint8Array(width * height), found: Candidate[] = [];
+    let stack = new Int32Array(1024);
     for (let y = 0; y < height; y++) {
         for (let x = 0; x < width; x++) {
             if (isBackground[y * width + x] || visited[y * width + x]) continue;
-            const stack = [x, y];
-            let minX = x, maxX = x, minY = y, maxY = y, reference = -1, allSimilar = true;
-            while (stack.length) {
-                const cy = stack.pop() as number, cx = stack.pop() as number;
-                if (visited[cy * width + cx]) continue;
-                visited[cy * width + cx] = 1;
+            stack[0] = y * width + x;
+            let top = 1, minX = x, maxX = x, minY = y, maxY = y, reference = -1, allSimilar = true;
+            while (top) {
+                const pixel = stack[--top], cy = pixel / width | 0, cx = pixel - cy * width;
+                if (visited[pixel]) continue;
+                visited[pixel] = 1;
                 minX = Math.min(minX, cx); maxX = Math.max(maxX, cx); minY = Math.min(minY, cy); maxY = Math.max(maxY, cy);
                 for (let dx = -1; dx <= 1; dx++) {
                     for (let dy = -1; dy <= 1; dy++) {
@@ -140,7 +142,13 @@ function candidates(planes: Float32Array[], stride: number, width: number, heigh
                         if (nx < 0 || ny < 0 || nx >= width || ny >= height) continue;
                         const i = ny * width + nx;
                         if (!isBackground[i]) {
-                            if (!visited[i]) stack.push(nx, ny);
+                            if (visited[i]) continue;
+                            if (top === stack.length) {
+                                const grown = new Int32Array(2 * top);
+                                grown.set(stack);
+                                stack = grown;
+                            }
+                            stack[top++] = i;
                         }
                         else if (reference < 0) reference = i;
                         else if (!similar(background, i, background, reference, VERY_SIMILAR)) allSimilar = false;