cross-image 0.2.4 → 0.4.1

package/script/src/formats/png_base.d.ts

@@ -43,7 +43,48 @@ export declare abstract class PNGBase {
     /**
      * Filter PNG data for encoding (using filter type 0 - None)
      */
-    protected filterData(data: Uint8Array, width: number, height: number): Uint8Array;
+    /**
+     * Apply PNG filter to image data based on compression level
+     * @param data Raw RGBA pixel data
+     * @param width Image width
+     * @param height Image height
+     * @param compressionLevel Compression level (0-9, default 6)
+     * @returns Filtered data with filter type byte per scanline
+     */
+    protected filterData(data: Uint8Array, width: number, height: number, compressionLevel?: number): Uint8Array;
+    /**
+     * Apply filter type 0 (None) - no filtering
+     */
+    private applyNoFilter;
+    /**
+     * Apply filter type 1 (Sub) - subtract left pixel
+     */
+    private applySubFilter;
+    /**
+     * Apply filter type 2 (Up) - subtract above pixel
+     */
+    private applyUpFilter;
+    /**
+     * Apply filter type 3 (Average) - subtract average of left and above
+     */
+    private applyAverageFilter;
+    /**
+     * Apply filter type 4 (Paeth) - Paeth predictor
+     */
+    private applyPaethFilter;
+    /**
+     * Calculate sum of absolute differences for a filtered scanline
+     * Lower values indicate better compression potential
+     */
+    private calculateFilterScore;
+    /**
+     * Apply adaptive filtering - choose best filter per scanline
+     */
+    private applyAdaptiveFilter;
+    /**
+     * Filter a single scanline with specified filter type
+     */
+    private filterScanline;
     /**
      * Get bytes per pixel for a given color type and bit depth
      */

package/script/src/formats/png_base.js

@@ -108,9 +108,7 @@ class PNGBase {
         for (let x = 0; x < scanline.length; x++) {
             const left = x >= bytesPerPixel ? scanline[x - bytesPerPixel] : 0;
             const above = prevLine ? prevLine[x] : 0;
-            const upperLeft = (x >= bytesPerPixel && prevLine)
-                ? prevLine[x - bytesPerPixel]
-                : 0;
+            const upperLeft = (x >= bytesPerPixel && prevLine) ? prevLine[x - bytesPerPixel] : 0;
             switch (filterType) {
                 case 0: // None
                     break;
@@ -124,8 +122,7 @@ class PNGBase {
                     scanline[x] = (scanline[x] + Math.floor((left + above) / 2)) & 0xff;
                     break;
                 case 4: // Paeth
-                    scanline[x] =
-                        (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
+                    scanline[x] = (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
                     break;
             }
         }
@@ -147,18 +144,211 @@ class PNGBase {
     /**
      * Filter PNG data for encoding (using filter type 0 - None)
      */
-    filterData(data, width, height) {
-        // Use filter type 0 (None) for simplicity
-        const filtered = new Uint8Array(height * (1 + width * 4));
+    /**
+     * Apply PNG filter to image data based on compression level
+     * @param data Raw RGBA pixel data
+     * @param width Image width
+     * @param height Image height
+     * @param compressionLevel Compression level (0-9, default 6)
+     * @returns Filtered data with filter type byte per scanline
+     */
+    filterData(data, width, height, compressionLevel = 6) {
+        // Choose filtering strategy based on compression level
+        if (compressionLevel <= 2) {
+            // Fast: No filtering
+            return this.applyNoFilter(data, width, height);
+        }
+        else if (compressionLevel <= 6) {
+            // Balanced: Sub filter
+            return this.applySubFilter(data, width, height);
+        }
+        else {
+            // Best: Adaptive filtering (choose best filter per scanline)
+            return this.applyAdaptiveFilter(data, width, height);
+        }
+    }
+    /**
+     * Apply filter type 0 (None) - no filtering
+     */
+    applyNoFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
         let pos = 0;
         for (let y = 0; y < height; y++) {
             filtered[pos++] = 0; // Filter type: None
-            for (let x = 0; x < width * 4; x++) {
-                filtered[pos++] = data[y * width * 4 + x];
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                filtered[pos++] = data[scanlineStart + x];
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 1 (Sub) - subtract left pixel
+     */
+    applySubFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 1; // Filter type: Sub
+            const scanlineStart = y * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                filtered[pos++] = (current - left) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 2 (Up) - subtract above pixel
+     */
+    applyUpFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 2; // Filter type: Up
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                filtered[pos++] = (current - up) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Apply filter type 3 (Average) - subtract average of left and above
+     */
+    applyAverageFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 3; // Filter type: Average
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const avg = Math.floor((left + up) / 2);
+                filtered[pos++] = (current - avg) & 0xff;
             }
         }
         return filtered;
     }
+    /**
+     * Apply filter type 4 (Paeth) - Paeth predictor
+     */
+    applyPaethFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let pos = 0;
+        for (let y = 0; y < height; y++) {
+            filtered[pos++] = 4; // Filter type: Paeth
+            const scanlineStart = y * bytesPerScanline;
+            const prevScanlineStart = (y - 1) * bytesPerScanline;
+            for (let x = 0; x < bytesPerScanline; x++) {
+                const current = data[scanlineStart + x];
+                const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+                const up = y > 0 ? data[prevScanlineStart + x] : 0;
+                const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+                const paeth = this.paethPredictor(left, up, upLeft);
+                filtered[pos++] = (current - paeth) & 0xff;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Calculate sum of absolute differences for a filtered scanline
+     * Lower values indicate better compression potential
+     */
+    calculateFilterScore(filtered) {
+        let sum = 0;
+        for (let i = 1; i < filtered.length; i++) {
+            const byte = filtered[i];
+            // Penalize larger absolute values
+            sum += byte < 128 ? byte : (256 - byte);
+        }
+        return sum;
+    }
+    /**
+     * Apply adaptive filtering - choose best filter per scanline
+     */
+    applyAdaptiveFilter(data, width, height) {
+        const bytesPerScanline = width * 4;
+        const filtered = new Uint8Array(height * (1 + bytesPerScanline));
+        let outPos = 0;
+        // Try each filter type and choose the best for each scanline
+        const filters = [
+            (y) => this.filterScanline(data, y, width, 0), // None
+            (y) => this.filterScanline(data, y, width, 1), // Sub
+            (y) => this.filterScanline(data, y, width, 2), // Up
+            (y) => this.filterScanline(data, y, width, 3), // Average
+            (y) => this.filterScanline(data, y, width, 4), // Paeth
+        ];
+        for (let y = 0; y < height; y++) {
+            let bestFilter = null;
+            let bestScore = Infinity;
+            // Try each filter type
+            for (const filterFn of filters) {
+                const result = filterFn(y);
+                const score = this.calculateFilterScore(result);
+                if (score < bestScore) {
+                    bestScore = score;
+                    bestFilter = result;
+                }
+            }
+            // Copy best filter result
+            if (bestFilter) {
+                filtered.set(bestFilter, outPos);
+                outPos += bestFilter.length;
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Filter a single scanline with specified filter type
+     */
+    filterScanline(data, y, width, filterType) {
+        const bytesPerScanline = width * 4;
+        const result = new Uint8Array(1 + bytesPerScanline);
+        result[0] = filterType;
+        const scanlineStart = y * bytesPerScanline;
+        const prevScanlineStart = (y - 1) * bytesPerScanline;
+        for (let x = 0; x < bytesPerScanline; x++) {
+            const current = data[scanlineStart + x];
+            const left = x >= 4 ? data[scanlineStart + x - 4] : 0;
+            const up = y > 0 ? data[prevScanlineStart + x] : 0;
+            const upLeft = (y > 0 && x >= 4) ? data[prevScanlineStart + x - 4] : 0;
+            let filtered;
+            switch (filterType) {
+                case 0: // None
+                    filtered = current;
+                    break;
+                case 1: // Sub
+                    filtered = (current - left) & 0xff;
+                    break;
+                case 2: // Up
+                    filtered = (current - up) & 0xff;
+                    break;
+                case 3: // Average
+                    filtered = (current - Math.floor((left + up) / 2)) & 0xff;
+                    break;
+                case 4: // Paeth
+                    filtered = (current - this.paethPredictor(left, up, upLeft)) & 0xff;
+                    break;
+                default:
+                    filtered = current;
+            }
+            result[x + 1] = filtered;
+        }
+        return result;
+    }
     /**
      * Get bytes per pixel for a given color type and bit depth
      */

package/script/src/formats/ppm.d.ts

@@ -1,4 +1,4 @@
-import type { ImageData, ImageFormat, ImageMetadata } from "../types.js";
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata } from "../types.js";
 /**
  * PPM format handler
  * Implements the Netpbm PPM (Portable PixMap) format.
@@ -34,14 +34,14 @@ export declare class PPMFormat implements ImageFormat {
      * @param data Raw PPM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     /**
      * Encode RGBA image data to PPM format (P6 binary)
      * Note: Alpha channel is ignored as PPM doesn't support transparency
      * @param imageData Image data to encode
      * @returns Encoded PPM image bytes
      */
-    encode(imageData: ImageData): Promise<Uint8Array>;
+    encode(imageData: ImageData, _options?: unknown): Promise<Uint8Array>;
     /**
      * Check if a byte is whitespace (space, tab, CR, LF)
      */

package/script/src/formats/ppm.js

@@ -59,7 +59,7 @@ class PPMFormat {
      * @param data Raw PPM image data
      * @returns Decoded image data with RGBA pixels
      */
-    decode(data) {
+    decode(data, _options) {
         if (!this.canDecode(data)) {
             throw new Error("Invalid PPM signature");
         }
@@ -211,7 +211,7 @@ class PPMFormat {
      * @param imageData Image data to encode
      * @returns Encoded PPM image bytes
      */
-    encode(imageData) {
+    encode(imageData, _options) {
         const { width, height, data } = imageData;
         // Validate input
         if (data.length !== width * height * 4) {

package/script/src/formats/tiff.d.ts

@@ -1,20 +1,9 @@
-import type { ImageData, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
-/**
- * Options for TIFF encoding
- */
-export interface TIFFEncodeOptions {
-    /** Compression method: "none" for uncompressed (default), "lzw" for LZW compression */
-    compression?: "none" | "lzw";
-    /** Encode as grayscale instead of RGB/RGBA */
-    grayscale?: boolean;
-    /** Encode as RGB without alpha channel (ignored if grayscale is true) */
-    rgb?: boolean;
-}
+import type { ImageData, ImageDecoderOptions, ImageFormat, ImageMetadata, MultiFrameImageData } from "../types.js";
 /**
  * TIFF format handler
- * Implements pure-JS TIFF decoder for uncompressed and LZW-compressed RGB/RGBA images
- * and encoder for uncompressed and LZW-compressed RGBA TIFFs. Falls back to ImageDecoder
- * for other compressed TIFFs (JPEG, PackBits, etc.)
+ * Implements pure-JS TIFF decoder for uncompressed, LZW, PackBits, and Deflate-compressed RGB/RGBA images
+ * and encoder for uncompressed, LZW, PackBits, and Deflate-compressed RGBA TIFFs. Falls back to ImageDecoder
+ * for JPEG-compressed TIFFs.
  * Supports multi-page TIFF files.
  */
 export declare class TIFFFormat implements ImageFormat {
@@ -38,12 +27,12 @@ export declare class TIFFFormat implements ImageFormat {
      * @param data Raw TIFF image data
      * @returns Decoded image data with RGBA pixels of first page
      */
-    decode(data: Uint8Array): Promise<ImageData>;
+    decode(data: Uint8Array, _options?: ImageDecoderOptions): Promise<ImageData>;
     encode(imageData: ImageData, options?: unknown): Promise<Uint8Array>;
     /**
      * Decode all pages from a multi-page TIFF
      */
-    decodeFrames(data: Uint8Array): Promise<MultiFrameImageData>;
+    decodeFrames(data: Uint8Array, _options?: ImageDecoderOptions): Promise<MultiFrameImageData>;
     /**
      * Encode multi-page TIFF
      */
@@ -65,7 +54,7 @@ export declare class TIFFFormat implements ImageFormat {
     private decodeUsingRuntime;
     private readString;
     /**
-     * Pure JavaScript TIFF decoder for uncompressed and LZW-compressed RGB/RGBA images
+     * Pure JavaScript TIFF decoder for uncompressed, LZW, PackBits, and Deflate-compressed RGB/RGBA images
      * Returns null if the TIFF uses unsupported features
      */
     private decodePureJS;