WebP lossless encoder: single symbol codes >= 256 take zero bits

A prefix code with one used symbol that can't be a simple code (a length
code, >= 256) is written as a normal code with one non-zero length.
Decoders read such a code with zero bits per symbol, the encoder wrote
one, so every following bit was off by one. Only prefix groups (since
3.7.0) produce such histograms. It broke lossless WebPs and the alpha of
lossy ones, which most optimized animations have.

Fixes #82

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

Author: claude

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 3.7.1
+
+### Fixes
+
+- Lossless WebPs, and lossy ones with alpha (most optimized animations), could be undecodable since 3.7.0 (#82): a
+  prefix group whose code had a single symbol of 256 or more (a length code) took a bit per symbol instead of none.
+
 ## 3.7.0
 
 ### Features

src/codecs/vp8l.ts

@@ -684,8 +684,9 @@ function writeCode(w: BitWriter, counts: ArrayLike<number>): Code {
         return { lengths, codes: canonicalCodes(lengths) };
     }
 
+    // a single symbol >= 256 can't be a simple code, a normal code with one non-zero length takes zero bits per symbol
+    // too (then the code length 1 it gets is only transmitted)
     const code = buildEncodeCode(counts);
-    // a normal code needs at least two symbols with non-zero length, which is given here
 
     // run length encode the code lengths: 16 repeats the previous non-zero length, 17/18 are runs of zeros
     const tokens: number[] = [], extras: number[] = [];
@@ -743,7 +744,7 @@ function writeCode(w: BitWriter, counts: ArrayLike<number>): Code {
         else if (t === 18) w.write(extras[i], 7);
     }
 
-    return code;
+    return used.length === 1 ? { lengths: code.lengths, codes: new Uint16Array(0) } : code;
 }
 
 // prefix symbol and extra bits of a length or distance value (>= 1)

tests/regressions.js

@@ -535,6 +535,25 @@ const rgba = (image, x, y) => Image.colorToRGBA(image.getPixelAt(x, y));
         assert(crc32(data) === zlib.crc32(data), 'crc32: wrong for a long buffer');
     }
 
+    // a VP8L prefix code with a single symbol >= 256 (here: a prefix group whose green alphabet only has one length
+    // code) takes zero bits per symbol, the encoder wrote one (#82). Lossy WebPs code their alpha as VP8L too
+    {
+        for (const [colors, width, height, rows, start] of [[16, 128, 128, 8, 2], [4, 128, 256, 16, 5], [2, 256, 600, 64, 3]]) {
+            let seed = start;
+            const random = () => (seed = seed * 1103515245 + 12345 >>> 0) / 2 ** 32;
+            // noisy rows on top and a noisy strip in the bottom left, the rest transparent
+            const image = new Image(width, height).fill((x, y) => {
+                const c = y < rows || y > height * 2 / 3 && x < 64 ? random() * colors | 0 : 0;
+                return c ? Image.rgbaToColor(c * 37, c * 11, c, 255) : 0;
+            });
+            for (const options of [{}, {quality: 85}]) {
+                const decoded = await Image.decode(await image.encodeWebP(options)).catch(err => assert(false, `WebP ${JSON.stringify(options)} of the ${width}x${height} mask: ${err.message}`));
+                for (let i = 3; i < image.bitmap.length; i += 4)
+                    assert(decoded.bitmap[i] === image.bitmap[i], `WebP ${JSON.stringify(options)} of the ${width}x${height} mask: wrong alpha`);
+            }
+        }
+    }
+
     // damaged fonts (truncated, bytes changed) render or throw a font error, quickly: no runaway memory or time (contours
     // with decreasing end points, composite glyphs containing themselves, huge COLR clip boxes)
     {