merge the TGA run length fix

Both change the TGA output buffer size: a packet header per 128 pixels of
a row, plus the extension area.

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

Author: matmen

src/codecs/tga.ts

@@ -216,8 +216,8 @@ export function encode(rgba: Uint8Array, width: number, height: number, extensio
     if (rgba.byteOffset % 4) rgba = rgba.slice(0, count * 4);
     const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, count);
 
-    // worst case: a header byte per 128 raw pixels
-    const out = new Uint8Array(18 + count * bpp + Math.ceil(count / 128) + 495 + 26);
+    // worst case: a header byte per 128 raw pixels of a row, the extension area and the footer
+    const out = new Uint8Array(18 + count * bpp + height * Math.ceil(width / 128) + 495 + 26);
     out[2] = 10; // RLE truecolor
     out[12] = width & 255; out[13] = width >> 8;
     out[14] = height & 255; out[15] = height >> 8;
@@ -234,9 +234,11 @@ export function encode(rgba: Uint8Array, width: number, height: number, extensio
     };
 
     for (let i = 0; i < count;) {
-        // a run of at least two equal pixels becomes a run packet, otherwise collect raw pixels until the next run
+        // a run of at least two equal pixels becomes a run packet, otherwise collect raw pixels until the next run;
+        // packets end with the row (TGA 2.0 requires it, Pillow rejects packets across rows)
+        const end = (Math.floor(i / width) + 1) * width;
         let run = 1;
-        while (run < 128 && i + run < count && pixels[i + run] === pixels[i]) run++;
+        while (run < 128 && i + run < end && pixels[i + run] === pixels[i]) run++;
         if (run >= 2) {
             out[o++] = 128 | run - 1;
             put(i);
@@ -245,7 +247,7 @@ export function encode(rgba: Uint8Array, width: number, height: number, extensio
         }
 
         let raw = 1;
-        while (raw < 128 && i + raw < count && !(i + raw + 1 < count && pixels[i + raw] === pixels[i + raw + 1])) raw++;
+        while (raw < 128 && i + raw < end && !(i + raw + 1 < end && pixels[i + raw] === pixels[i + raw + 1])) raw++;
         out[o++] = raw - 1;
         for (let k = 0; k < raw; k++) put(i + k);
         i += raw;

tests/tga.js

@@ -55,12 +55,23 @@ const rgba = (image, x, y) => image.getRGBAAt(x, y).join();
     for (const image of [
         new Image(50, 7).fill((x, y) => Image.rgbaToColor(x * 5, y * 30, (x >> 2) * 40, x % 3 ? 255 : 100)),
         new Image(300, 2).fill(0x336699ff),
-        new Image(1, 1).fill(0x00000000)
+        new Image(1, 1).fill(0x00000000),
+        // a header per pixel: one pixel rows, alternating
+        new Image(1, 300).fill((x, y) => y & 1 ? 0xffffffff : 0x000000ff)
     ]) {
         const encoded = await image.encodeTGA();
         if (ImageType.getType(encoded) !== 'tga') panic('encoded TGA not recognized');
         const back = await Image.decode(encoded);
         if (!Buffer.from(back.bitmap).equals(Buffer.from(image.bitmap))) panic(`TGA: ${image.width}x${image.height} didn't round trip`);
+
+        // packets don't cross rows
+        const bpp = encoded[16] / 8;
+        for (let o = 18, pixel = 0; pixel < image.width * image.height;) {
+            const n = (encoded[o] & 127) + 1;
+            if (Math.floor(pixel / image.width) !== Math.floor((pixel + n - 1) / image.width)) panic(`TGA: ${image.width}x${image.height} has a packet across rows`);
+            o += 1 + (encoded[o] & 128 ? bpp : n * bpp);
+            pixel += n;
+        }
     }
     const opaque = await new Image(4, 4).fill(0xff0000ff).encodeTGA();
     if (opaque[16] !== 24) panic('TGA: opaque images should be stored with 24 bits');