cross-image 0.2.4 → 0.4.0

package/script/src/utils/tiff_packbits.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * PackBits compression/decompression for TIFF
+ * PackBits is a simple run-length encoding (RLE) scheme used in TIFF images
+ * Compression code: 32773
+ *
+ * Format:
+ * - Header byte n:
+ *   - If n >= 0 and n <= 127: Copy the next n+1 bytes literally
+ *   - If n >= -127 and n <= -1: Repeat the next byte -n+1 times
+ *   - If n = -128: No operation (skip)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packBitsCompress = packBitsCompress;
+exports.packBitsDecompress = packBitsDecompress;
+/**
+ * Compress data using PackBits RLE
+ * @param data Uncompressed data
+ * @returns Compressed data
+ */
+function packBitsCompress(data) {
+    const result = [];
+    let i = 0;
+    while (i < data.length) {
+        // Look for runs (repeated bytes)
+        let runLength = 1;
+        while (i + runLength < data.length &&
+            data[i + runLength] === data[i] &&
+            runLength < 128) {
+            runLength++;
+        }
+        // If we have a run of 2 or more, encode it as a run
+        if (runLength >= 2) {
+            result.push(-(runLength - 1) & 0xff); // Two's complement representation
+            result.push(data[i]);
+            i += runLength;
+        }
+        else {
+            // Look for literals (non-repeating bytes)
+            const literalStart = i;
+            let literalLength = 1;
+            while (i + literalLength < data.length &&
+                literalLength < 128) {
+                // Check if we're starting a run
+                if (i + literalLength + 1 < data.length &&
+                    data[i + literalLength] === data[i + literalLength + 1]) {
+                    // We found a run, stop the literal sequence here
+                    break;
+                }
+                literalLength++;
+            }
+            result.push(literalLength - 1);
+            for (let j = 0; j < literalLength; j++) {
+                result.push(data[literalStart + j]);
+            }
+            i += literalLength;
+        }
+    }
+    return new Uint8Array(result);
+}
+/**
+ * Decompress PackBits RLE data
+ * @param data Compressed data
+ * @returns Decompressed data
+ */
+function packBitsDecompress(data) {
+    const result = [];
+    let i = 0;
+    while (i < data.length) {
+        const header = data[i++];
+        if (header === 128) {
+            // No operation, skip
+            continue;
+        }
+        else if (header < 128) {
+            // Literal run: copy next (header + 1) bytes
+            const count = header + 1;
+            for (let j = 0; j < count && i < data.length; j++) {
+                result.push(data[i++]);
+            }
+        }
+        else {
+            // Repeated run: repeat next byte (257 - header) times
+            const count = 257 - header;
+            if (i < data.length) {
+                const value = data[i++];
+                for (let j = 0; j < count; j++) {
+                    result.push(value);
+                }
+            }
+        }
+    }
+    return new Uint8Array(result);
+}

package/script/src/utils/webp_decoder.d.ts

@@ -19,9 +19,11 @@
  * @see https://developers.google.com/speed/webp/docs/riff_container
  * @see https://developers.google.com/speed/webp/docs/webp_lossless_bitstream_specification
  */
+import type { ImageDecoderOptions } from "../types.js";
 export declare class WebPDecoder {
     private data;
-    constructor(data: Uint8Array);
+    private options;
+    constructor(data: Uint8Array, settings?: ImageDecoderOptions);
     decode(): {
         width: number;
         height: number;

package/script/src/utils/webp_decoder.js

@@ -96,7 +96,6 @@ class HuffmanTable {
             const bit = reader.readBits(1);
             node = bit === 0 ? node.left : node.right;
             if (!node) {
-                // console.log("Invalid Huffman code - walked off tree");
                 throw new Error("Invalid Huffman code");
             }
         }
@@ -167,14 +166,24 @@ class BitReader {
     }
 }
 class WebPDecoder {
-    constructor(data) {
+    constructor(data, settings = {}) {
         Object.defineProperty(this, "data", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.data = data;
+        this.options = {
+            tolerantDecoding: settings.tolerantDecoding ?? true,
+            onWarning: settings.onWarning,
+        };
     }
     decode() {
         // Verify WebP signature
@@ -281,66 +290,142 @@ class WebPDecoder {
         const numPixels = width * height;
         // Color cache for repeated colors
         const colorCache = new Uint32Array(colorCacheSize);
-        for (let i = 0; i < numPixels;) {
-            // Read green channel (which determines the code type)
-            const green = huffmanTables.green.readSymbol(reader);
-            if (green < 256) {
-                // Literal pixel
-                const red = huffmanTables.red.readSymbol(reader);
-                const blue = huffmanTables.blue.readSymbol(reader);
-                const alpha = alphaUsed !== 0
-                    ? huffmanTables.alpha.readSymbol(reader)
-                    : 255;
-                pixelData[pixelIndex++] = red;
-                pixelData[pixelIndex++] = green;
-                pixelData[pixelIndex++] = blue;
-                pixelData[pixelIndex++] = alpha;
-                // Add to color cache if enabled
-                if (useColorCache) {
-                    const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
-                    colorCache[i % colorCacheSize] = color;
+        if (this.options.tolerantDecoding) {
+            // Tolerant mode: continue decoding even if errors occur
+            try {
+                for (let i = 0; i < numPixels;) {
+                    // Read green channel (which determines the code type)
+                    const green = huffmanTables.green.readSymbol(reader);
+                    if (green < 256) {
+                        // Literal pixel
+                        const red = huffmanTables.red.readSymbol(reader);
+                        const blue = huffmanTables.blue.readSymbol(reader);
+                        const alpha = alphaUsed !== 0 ? huffmanTables.alpha.readSymbol(reader) : 255;
+                        pixelData[pixelIndex++] = red;
+                        pixelData[pixelIndex++] = green;
+                        pixelData[pixelIndex++] = blue;
+                        pixelData[pixelIndex++] = alpha;
+                        // Add to color cache if enabled
+                        if (useColorCache) {
+                            const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
+                            colorCache[i % colorCacheSize] = color;
+                        }
+                        i++;
+                    }
+                    else if (green < 256 + 24) {
+                        // Backward reference (LZ77)
+                        const lengthSymbol = green - 256;
+                        const length = this.getLength(lengthSymbol, reader);
+                        const distancePrefix = huffmanTables.distance.readSymbol(reader);
+                        const distance = this.getDistance(distancePrefix, reader);
+                        // Copy pixels from earlier in the stream
+                        const srcIndex = pixelIndex - distance * 4;
+                        if (srcIndex < 0) {
+                            throw new Error("Invalid backward reference");
+                        }
+                        for (let j = 0; j < length; j++) {
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
+                            pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
+                            // Add to color cache
+                            if (useColorCache) {
+                                const color = (pixelData[pixelIndex - 1] << 24) |
+                                    (pixelData[pixelIndex - 2] << 16) |
+                                    (pixelData[pixelIndex - 3] << 8) |
+                                    pixelData[pixelIndex - 4];
+                                colorCache[(i + j) % colorCacheSize] = color;
+                            }
+                        }
+                        i += length;
+                    }
+                    else {
+                        // Color cache reference
+                        const cacheIndex = green - 256 - 24;
+                        if (cacheIndex >= colorCacheSize) {
+                            throw new Error("Invalid color cache index");
+                        }
+                        const color = colorCache[cacheIndex];
+                        pixelData[pixelIndex++] = color & 0xff; // R
+                        pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
+                        pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
+                        pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
+                        i++;
+                    }
                 }
-                i++;
             }
-            else if (green < 256 + 24) {
-                // Backward reference (LZ77)
-                const lengthSymbol = green - 256;
-                const length = this.getLength(lengthSymbol, reader);
-                const distancePrefix = huffmanTables.distance.readSymbol(reader);
-                const distance = this.getDistance(distancePrefix, reader);
-                // Copy pixels from earlier in the stream
-                const srcIndex = pixelIndex - distance * 4;
-                if (srcIndex < 0) {
-                    throw new Error("Invalid backward reference");
+            catch (e) {
+                // Tolerant decoding: fill remaining pixels with gray (128, 128, 128, 255)
+                this.options.onWarning?.(`WebP VP8L: Partial decode at pixel ${pixelIndex / 4}/${numPixels}`, e);
+                while (pixelIndex < pixelData.length) {
+                    pixelData[pixelIndex++] = 128; // R
+                    pixelData[pixelIndex++] = 128; // G
+                    pixelData[pixelIndex++] = 128; // B
+                    pixelData[pixelIndex++] = 255; // A
                 }
-                for (let j = 0; j < length; j++) {
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
-                    pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
-                    // Add to color cache
+            }
+        }
+        else {
+            // Non-tolerant mode: throw on first error
+            for (let i = 0; i < numPixels;) {
+                // Read green channel (which determines the code type)
+                const green = huffmanTables.green.readSymbol(reader);
+                if (green < 256) {
+                    // Literal pixel
+                    const red = huffmanTables.red.readSymbol(reader);
+                    const blue = huffmanTables.blue.readSymbol(reader);
+                    const alpha = alphaUsed !== 0 ? huffmanTables.alpha.readSymbol(reader) : 255;
+                    pixelData[pixelIndex++] = red;
+                    pixelData[pixelIndex++] = green;
+                    pixelData[pixelIndex++] = blue;
+                    pixelData[pixelIndex++] = alpha;
+                    // Add to color cache if enabled
                     if (useColorCache) {
-                        const color = (pixelData[pixelIndex - 1] << 24) |
-                            (pixelData[pixelIndex - 2] << 16) |
-                            (pixelData[pixelIndex - 3] << 8) |
-                            pixelData[pixelIndex - 4];
-                        colorCache[(i + j) % colorCacheSize] = color;
+                        const color = (alpha << 24) | (blue << 16) | (green << 8) | red;
+                        colorCache[i % colorCacheSize] = color;
                     }
+                    i++;
                 }
-                i += length;
-            }
-            else {
-                // Color cache reference
-                const cacheIndex = green - 256 - 24;
-                if (cacheIndex >= colorCacheSize) {
-                    throw new Error("Invalid color cache index");
+                else if (green < 256 + 24) {
+                    // Backward reference (LZ77)
+                    const lengthSymbol = green - 256;
+                    const length = this.getLength(lengthSymbol, reader);
+                    const distancePrefix = huffmanTables.distance.readSymbol(reader);
+                    const distance = this.getDistance(distancePrefix, reader);
+                    // Copy pixels from earlier in the stream
+                    const srcIndex = pixelIndex - distance * 4;
+                    if (srcIndex < 0) {
+                        throw new Error("Invalid backward reference");
+                    }
+                    for (let j = 0; j < length; j++) {
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 1];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 2];
+                        pixelData[pixelIndex++] = pixelData[srcIndex + j * 4 + 3];
+                        // Add to color cache
+                        if (useColorCache) {
+                            const color = (pixelData[pixelIndex - 1] << 24) |
+                                (pixelData[pixelIndex - 2] << 16) |
+                                (pixelData[pixelIndex - 3] << 8) |
+                                pixelData[pixelIndex - 4];
+                            colorCache[(i + j) % colorCacheSize] = color;
+                        }
+                    }
+                    i += length;
+                }
+                else {
+                    // Color cache reference
+                    const cacheIndex = green - 256 - 24;
+                    if (cacheIndex >= colorCacheSize) {
+                        throw new Error("Invalid color cache index");
+                    }
+                    const color = colorCache[cacheIndex];
+                    pixelData[pixelIndex++] = color & 0xff; // R
+                    pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
+                    pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
+                    pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
+                    i++;
                 }
-                const color = colorCache[cacheIndex];
-                pixelData[pixelIndex++] = color & 0xff; // R
-                pixelData[pixelIndex++] = (color >> 8) & 0xff; // G
-                pixelData[pixelIndex++] = (color >> 16) & 0xff; // B
-                pixelData[pixelIndex++] = (color >> 24) & 0xff; // A
-                i++;
             }
         }
         return pixelData;
@@ -381,9 +466,7 @@ class WebPDecoder {
             const isFirstEightBits = reader.readBits(1);
             const symbols = [];
             for (let i = 0; i < numSymbols; i++) {
-                const symbolBits = isFirstEightBits
-                    ? reader.readBits(8)
-                    : reader.readBits(1);
+                const symbolBits = isFirstEightBits ? reader.readBits(8) : reader.readBits(1);
                 symbols.push(symbolBits);
             }
             // Build simple Huffman table
@@ -399,9 +482,7 @@ class WebPDecoder {
         }
         else {
             // Complex code - read code lengths
-            const maxSymbol = isGreen
-                ? (256 + 24 + (useColorCache ? (1 << colorCacheBits) : 0))
-                : 256;
+            const maxSymbol = isGreen ? (256 + 24 + (useColorCache ? (1 << colorCacheBits) : 0)) : 256;
             const codeLengths = this.readCodeLengths(reader, maxSymbol);
             this.buildHuffmanTable(table, codeLengths);
         }
@@ -409,7 +490,7 @@ class WebPDecoder {
     readCodeLengths(reader, maxSymbol) {
         // Read code length codes (used to encode the actual code lengths)
         const numCodeLengthCodes = reader.readBits(4) + 4;
-        const codeLengthCodeLengths = new Array(19).fill(0);
+        const codeLengthCodeLengths = new Uint8Array(19);
         // Code length code order
         const codeLengthCodeOrder = [
             17,
@@ -445,7 +526,7 @@ class WebPDecoder {
         const codeLengthTable = new HuffmanTable();
         this.buildHuffmanTable(codeLengthTable, codeLengthCodeLengths);
         // Read actual code lengths
-        const codeLengths = new Array(maxSymbol).fill(0);
+        const codeLengths = new Uint8Array(maxSymbol);
         let i = 0;
         while (i < maxSymbol) {
             const code = codeLengthTable.readSymbol(reader);

package/script/src/utils/webp_encoder.js

@@ -372,7 +372,7 @@ class WebPEncoder {
      * Returns an array where index is the symbol and value is the code length
      */
     calculateCodeLengths(frequencies, maxSymbol, maxCodeLength = 15) {
-        const codeLengths = new Array(maxSymbol).fill(0);
+        const codeLengths = new Uint8Array(maxSymbol);
         // Get symbols with non-zero frequencies
         const symbols = Array.from(frequencies.keys()).sort((a, b) => a - b);
         if (symbols.length === 0)
@@ -380,7 +380,6 @@ class WebPEncoder {
         // For a single symbol, use code length 1
         // (Canonical Huffman codes require length >= 1)
         if (symbols.length === 1) {
-            // console.log(`Single symbol ${symbols[0]}, forcing length 1`);
             codeLengths[symbols[0]] = 1;
             return codeLengths;
         }
@@ -427,7 +426,6 @@ class WebPEncoder {
         // If tree is too deep, flatten frequencies and rebuild
         let attempts = 0;
         while (maxDepth > maxCodeLength && attempts < 5) {
-            // console.log(`Tree too deep (${maxDepth} > ${maxCodeLength}), flattening...`);
             attempts++;
             // Add bias to frequencies to flatten the tree
             // Increase bias with each attempt
@@ -442,11 +440,8 @@ class WebPEncoder {
             maxDepth = 0;
             checkDepth(root, 0);
         }
-        if (maxDepth > maxCodeLength) {
-            console.warn(`Failed to reduce Huffman tree depth to ${maxCodeLength} (current: ${maxDepth})`);
-            // Force hard limit by sorting and assigning lengths?
-            // For now, let's just see if this is happening.
-        }
+        // If tree depth couldn't be reduced, encoding may fail but we'll try anyway
+        // This is an internal limitation that doesn't affect most images
         // Calculate code lengths by traversing tree (iterative to avoid deep recursion)
         const stack = [{
                 node: root,
@@ -488,7 +483,7 @@ class WebPEncoder {
             }
         }
         // Count symbols at each length
-        const lengthCounts = new Array(maxLength + 1).fill(0);
+        const lengthCounts = new Uint32Array(maxLength + 1);
         for (let i = 0; i < codeLengths.length; i++) {
             if (codeLengths[i] > 0) {
                 lengthCounts[codeLengths[i]]++;
@@ -496,7 +491,7 @@ class WebPEncoder {
         }
         // Generate first code for each length
         let code = 0;
-        const nextCode = new Array(maxLength + 1).fill(0);
+        const nextCode = new Uint32Array(maxLength + 1);
         for (let len = 1; len <= maxLength; len++) {
             code = (code + lengthCounts[len - 1]) << 1;
             nextCode[len] = code;
@@ -628,7 +623,6 @@ class WebPEncoder {
         }
         numCodeLengthCodes = Math.max(4, numCodeLengthCodes);
         // Write number of code length codes
-        // console.log(`Complex Huffman: numCodeLengthCodes=${numCodeLengthCodes}, rleEncoded.length=${rleEncoded.length}`);
         writer.writeBits(numCodeLengthCodes - 4, 4);
         // Write code length code lengths
         for (let i = 0; i < numCodeLengthCodes; i++) {