cross-image 0.2.0 → 0.2.2

package/esm/src/formats/png_base.js

@@ -0,0 +1,487 @@
+// Constants for unit conversions
+const INCHES_PER_METER = 39.3701;
+/**
+ * Base class for PNG and APNG format handlers
+ * Contains shared utility methods for PNG chunk manipulation and metadata parsing
+ */
+export class PNGBase {
+    /**
+     * Read a 32-bit unsigned integer (big-endian)
+     */
+    readUint32(data, offset) {
+        return (data[offset] << 24) | (data[offset + 1] << 16) |
+            (data[offset + 2] << 8) | data[offset + 3];
+    }
+    /**
+     * Read a 16-bit unsigned integer (big-endian)
+     */
+    readUint16(data, offset) {
+        return (data[offset] << 8) | data[offset + 1];
+    }
+    /**
+     * Write a 32-bit unsigned integer (big-endian)
+     */
+    writeUint32(data, offset, value) {
+        data[offset] = (value >>> 24) & 0xff;
+        data[offset + 1] = (value >>> 16) & 0xff;
+        data[offset + 2] = (value >>> 8) & 0xff;
+        data[offset + 3] = value & 0xff;
+    }
+    /**
+     * Write a 16-bit unsigned integer (big-endian)
+     */
+    writeUint16(data, offset, value) {
+        data[offset] = (value >>> 8) & 0xff;
+        data[offset + 1] = value & 0xff;
+    }
+    /**
+     * Decompress PNG data using deflate
+     */
+    async inflate(data) {
+        const stream = new Response(data).body
+            .pipeThrough(new DecompressionStream("deflate"));
+        const decompressed = await new Response(stream).arrayBuffer();
+        return new Uint8Array(decompressed);
+    }
+    /**
+     * Compress PNG data using deflate
+     */
+    async deflate(data) {
+        const stream = new Response(data).body
+            .pipeThrough(new CompressionStream("deflate"));
+        const compressed = await new Response(stream).arrayBuffer();
+        return new Uint8Array(compressed);
+    }
+    /**
+     * Unfilter PNG scanlines and convert to RGBA
+     */
+    unfilterAndConvert(data, width, height, bitDepth, colorType) {
+        const rgba = new Uint8Array(width * height * 4);
+        const bytesPerPixel = this.getBytesPerPixel(colorType, bitDepth);
+        const scanlineLength = width * bytesPerPixel;
+        let dataPos = 0;
+        const scanlines = [];
+        for (let y = 0; y < height; y++) {
+            const filterType = data[dataPos++];
+            const scanline = new Uint8Array(scanlineLength);
+            for (let x = 0; x < scanlineLength; x++) {
+                scanline[x] = data[dataPos++];
+            }
+            this.unfilterScanline(scanline, y > 0 ? scanlines[y - 1] : null, filterType, bytesPerPixel);
+            scanlines.push(scanline);
+            // Convert to RGBA
+            for (let x = 0; x < width; x++) {
+                const outIdx = (y * width + x) * 4;
+                if (colorType === 6) { // RGBA
+                    rgba[outIdx] = scanline[x * 4];
+                    rgba[outIdx + 1] = scanline[x * 4 + 1];
+                    rgba[outIdx + 2] = scanline[x * 4 + 2];
+                    rgba[outIdx + 3] = scanline[x * 4 + 3];
+                }
+                else if (colorType === 2) { // RGB
+                    rgba[outIdx] = scanline[x * 3];
+                    rgba[outIdx + 1] = scanline[x * 3 + 1];
+                    rgba[outIdx + 2] = scanline[x * 3 + 2];
+                    rgba[outIdx + 3] = 255;
+                }
+                else if (colorType === 0) { // Grayscale
+                    const gray = scanline[x];
+                    rgba[outIdx] = gray;
+                    rgba[outIdx + 1] = gray;
+                    rgba[outIdx + 2] = gray;
+                    rgba[outIdx + 3] = 255;
+                }
+                else {
+                    throw new Error(`Unsupported PNG color type: ${colorType}`);
+                }
+            }
+        }
+        return rgba;
+    }
+    /**
+     * Unfilter a single PNG scanline
+     */
+    unfilterScanline(scanline, prevLine, filterType, bytesPerPixel) {
+        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;
+            switch (filterType) {
+                case 0: // None
+                    break;
+                case 1: // Sub
+                    scanline[x] = (scanline[x] + left) & 0xff;
+                    break;
+                case 2: // Up
+                    scanline[x] = (scanline[x] + above) & 0xff;
+                    break;
+                case 3: // Average
+                    scanline[x] = (scanline[x] + Math.floor((left + above) / 2)) & 0xff;
+                    break;
+                case 4: // Paeth
+                    scanline[x] =
+                        (scanline[x] + this.paethPredictor(left, above, upperLeft)) & 0xff;
+                    break;
+            }
+        }
+    }
+    /**
+     * Paeth predictor for PNG filtering
+     */
+    paethPredictor(a, b, c) {
+        const p = a + b - c;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c);
+        if (pa <= pb && pa <= pc)
+            return a;
+        if (pb <= pc)
+            return b;
+        return c;
+    }
+    /**
+     * 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));
+        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];
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Get bytes per pixel for a given color type and bit depth
+     */
+    getBytesPerPixel(colorType, bitDepth) {
+        const bitsPerPixel = this.getBitsPerPixel(colorType, bitDepth);
+        return Math.ceil(bitsPerPixel / 8);
+    }
+    /**
+     * Get bits per pixel for a given color type and bit depth
+     */
+    getBitsPerPixel(colorType, bitDepth) {
+        switch (colorType) {
+            case 0: // Grayscale
+                return bitDepth;
+            case 2: // RGB
+                return bitDepth * 3;
+            case 3: // Palette
+                return bitDepth;
+            case 4: // Grayscale + Alpha
+                return bitDepth * 2;
+            case 6: // RGBA
+                return bitDepth * 4;
+            default:
+                throw new Error(`Unknown color type: ${colorType}`);
+        }
+    }
+    /**
+     * Create a PNG chunk with length, type, data, and CRC
+     */
+    createChunk(type, data) {
+        const chunk = new Uint8Array(12 + data.length);
+        this.writeUint32(chunk, 0, data.length);
+        chunk[4] = type.charCodeAt(0);
+        chunk[5] = type.charCodeAt(1);
+        chunk[6] = type.charCodeAt(2);
+        chunk[7] = type.charCodeAt(3);
+        chunk.set(data, 8);
+        const crc = this.crc32(chunk.slice(4, 8 + data.length));
+        this.writeUint32(chunk, 8 + data.length, crc);
+        return chunk;
+    }
+    /**
+     * Calculate CRC32 checksum
+     */
+    crc32(data) {
+        let crc = 0xffffffff;
+        for (let i = 0; i < data.length; i++) {
+            crc ^= data[i];
+            for (let j = 0; j < 8; j++) {
+                crc = (crc & 1) ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+            }
+        }
+        return (crc ^ 0xffffffff) >>> 0;
+    }
+    // Metadata parsing methods
+    /**
+     * Parse pHYs (physical pixel dimensions) chunk
+     */
+    parsePhysChunk(data, metadata, width, height) {
+        if (data.length < 9)
+            return;
+        const pixelsPerUnitX = this.readUint32(data, 0);
+        const pixelsPerUnitY = this.readUint32(data, 4);
+        const unit = data[8];
+        if (unit === 1 && pixelsPerUnitX > 0 && pixelsPerUnitY > 0) {
+            metadata.dpiX = Math.round(pixelsPerUnitX / INCHES_PER_METER);
+            metadata.dpiY = Math.round(pixelsPerUnitY / INCHES_PER_METER);
+            metadata.physicalWidth = width / metadata.dpiX;
+            metadata.physicalHeight = height / metadata.dpiY;
+        }
+    }
+    /**
+     * Parse tEXt (text) chunk
+     */
+    parseTextChunk(data, metadata) {
+        const nullIndex = data.indexOf(0);
+        if (nullIndex === -1)
+            return;
+        const keyword = new TextDecoder().decode(data.slice(0, nullIndex));
+        const text = new TextDecoder().decode(data.slice(nullIndex + 1));
+        switch (keyword.toLowerCase()) {
+            case "title":
+                metadata.title = text;
+                break;
+            case "author":
+                metadata.author = text;
+                break;
+            case "description":
+                metadata.description = text;
+                break;
+            case "copyright":
+                metadata.copyright = text;
+                break;
+            default:
+                if (!metadata.custom)
+                    metadata.custom = {};
+                metadata.custom[keyword] = text;
+        }
+    }
+    /**
+     * Parse iTXt (international text) chunk
+     */
+    parseITxtChunk(data, metadata) {
+        let pos = 0;
+        const nullIndex = data.indexOf(0, pos);
+        if (nullIndex === -1 || pos >= data.length)
+            return;
+        const keyword = new TextDecoder().decode(data.slice(pos, nullIndex));
+        pos = nullIndex + 1;
+        if (pos + 2 > data.length)
+            return;
+        pos += 2; // Skip compression flag and method
+        const languageNullIndex = data.indexOf(0, pos);
+        if (languageNullIndex === -1 || pos >= data.length)
+            return;
+        pos = languageNullIndex + 1;
+        const translatedKeywordNullIndex = data.indexOf(0, pos);
+        if (translatedKeywordNullIndex === -1 || pos >= data.length)
+            return;
+        pos = translatedKeywordNullIndex + 1;
+        if (pos >= data.length)
+            return;
+        const text = new TextDecoder("utf-8").decode(data.slice(pos));
+        switch (keyword.toLowerCase()) {
+            case "title":
+                metadata.title = text;
+                break;
+            case "author":
+                metadata.author = text;
+                break;
+            case "description":
+                metadata.description = text;
+                break;
+            case "copyright":
+                metadata.copyright = text;
+                break;
+            default:
+                if (!metadata.custom)
+                    metadata.custom = {};
+                metadata.custom[keyword] = text;
+        }
+    }
+    /**
+     * Parse eXIf (EXIF) chunk
+     */
+    parseExifChunk(data, metadata) {
+        if (data.length < 8)
+            return;
+        try {
+            const byteOrder = String.fromCharCode(data[0], data[1]);
+            const littleEndian = byteOrder === "II";
+            const ifd0Offset = littleEndian
+                ? data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24)
+                : (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
+            if (ifd0Offset + 2 > data.length)
+                return;
+            const numEntries = littleEndian
+                ? data[ifd0Offset] | (data[ifd0Offset + 1] << 8)
+                : (data[ifd0Offset] << 8) | data[ifd0Offset + 1];
+            for (let i = 0; i < numEntries; i++) {
+                const entryOffset = ifd0Offset + 2 + i * 12;
+                if (entryOffset + 12 > data.length)
+                    break;
+                const tag = littleEndian
+                    ? data[entryOffset] | (data[entryOffset + 1] << 8)
+                    : (data[entryOffset] << 8) | data[entryOffset + 1];
+                if (tag === 0x0132) {
+                    const valueOffset = littleEndian
+                        ? data[entryOffset + 8] | (data[entryOffset + 9] << 8) |
+                            (data[entryOffset + 10] << 16) | (data[entryOffset + 11] << 24)
+                        : (data[entryOffset + 8] << 24) | (data[entryOffset + 9] << 16) |
+                            (data[entryOffset + 10] << 8) | data[entryOffset + 11];
+                    if (valueOffset < data.length) {
+                        const nullIndex = data.indexOf(0, valueOffset);
+                        if (nullIndex > valueOffset) {
+                            const dateStr = new TextDecoder().decode(data.slice(valueOffset, nullIndex));
+                            const match = dateStr.match(/^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
+                            if (match) {
+                                metadata.creationDate = new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]), parseInt(match[4]), parseInt(match[5]), parseInt(match[6]));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (_e) {
+            // Ignore EXIF parsing errors
+        }
+    }
+    /**
+     * Create pHYs (physical pixel dimensions) chunk
+     */
+    createPhysChunk(metadata) {
+        const chunk = new Uint8Array(9);
+        const dpiX = metadata.dpiX ?? 72;
+        const dpiY = metadata.dpiY ?? 72;
+        const pixelsPerMeterX = Math.round(dpiX * INCHES_PER_METER);
+        const pixelsPerMeterY = Math.round(dpiY * INCHES_PER_METER);
+        this.writeUint32(chunk, 0, pixelsPerMeterX);
+        this.writeUint32(chunk, 4, pixelsPerMeterY);
+        chunk[8] = 1;
+        return chunk;
+    }
+    /**
+     * Create tEXt (text) chunk
+     */
+    createTextChunk(keyword, text) {
+        const keywordBytes = new TextEncoder().encode(keyword);
+        const textBytes = new TextEncoder().encode(text);
+        const chunk = new Uint8Array(keywordBytes.length + 1 + textBytes.length);
+        chunk.set(keywordBytes, 0);
+        chunk[keywordBytes.length] = 0;
+        chunk.set(textBytes, keywordBytes.length + 1);
+        return chunk;
+    }
+    /**
+     * Create eXIf (EXIF) chunk
+     */
+    createExifChunk(metadata) {
+        const entries = [];
+        if (metadata.creationDate) {
+            const date = metadata.creationDate;
+            const dateStr = `${date.getFullYear()}:${String(date.getMonth() + 1).padStart(2, "0")}:${String(date.getDate()).padStart(2, "0")} ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(date.getSeconds()).padStart(2, "0")}\0`;
+            entries.push({
+                tag: 0x0132,
+                type: 2,
+                value: new TextEncoder().encode(dateStr),
+            });
+        }
+        if (entries.length === 0)
+            return null;
+        const exif = [];
+        exif.push(0x49, 0x49); // "II"
+        exif.push(0x2a, 0x00); // 42
+        exif.push(0x08, 0x00, 0x00, 0x00);
+        exif.push(entries.length & 0xff, (entries.length >> 8) & 0xff);
+        let dataOffset = 8 + 2 + entries.length * 12 + 4;
+        for (const entry of entries) {
+            exif.push(entry.tag & 0xff, (entry.tag >> 8) & 0xff);
+            exif.push(entry.type & 0xff, (entry.type >> 8) & 0xff);
+            const count = entry.value.length;
+            exif.push(count & 0xff, (count >> 8) & 0xff, (count >> 16) & 0xff, (count >> 24) & 0xff);
+            if (entry.value.length <= 4) {
+                for (let i = 0; i < 4; i++) {
+                    exif.push(i < entry.value.length ? entry.value[i] : 0);
+                }
+            }
+            else {
+                exif.push(dataOffset & 0xff, (dataOffset >> 8) & 0xff, (dataOffset >> 16) & 0xff, (dataOffset >> 24) & 0xff);
+                dataOffset += entry.value.length;
+            }
+        }
+        exif.push(0x00, 0x00, 0x00, 0x00);
+        for (const entry of entries) {
+            if (entry.value.length > 4) {
+                for (const byte of entry.value) {
+                    exif.push(byte);
+                }
+            }
+        }
+        return new Uint8Array(exif);
+    }
+    /**
+     * Concatenate multiple byte arrays into a single Uint8Array
+     */
+    concatenateChunks(chunks) {
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.data.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk.data, offset);
+            offset += chunk.data.length;
+        }
+        return result;
+    }
+    /**
+     * Concatenate multiple Uint8Arrays into a single Uint8Array
+     */
+    concatenateArrays(arrays) {
+        const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const arr of arrays) {
+            result.set(arr, offset);
+            offset += arr.length;
+        }
+        return result;
+    }
+    /**
+     * Add metadata chunks to the chunks array
+     * Shared method to avoid duplication between PNG and APNG encoding
+     */
+    addMetadataChunks(chunks, metadata) {
+        if (!metadata)
+            return;
+        // Add pHYs chunk for DPI information
+        if (metadata.dpiX !== undefined || metadata.dpiY !== undefined) {
+            const physChunk = this.createPhysChunk(metadata);
+            chunks.push(this.createChunk("pHYs", physChunk));
+        }
+        // Add tEXt chunks for standard metadata
+        if (metadata.title !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Title", metadata.title)));
+        }
+        if (metadata.author !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Author", metadata.author)));
+        }
+        if (metadata.description !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Description", metadata.description)));
+        }
+        if (metadata.copyright !== undefined) {
+            chunks.push(this.createChunk("tEXt", this.createTextChunk("Copyright", metadata.copyright)));
+        }
+        // Add custom metadata fields
+        if (metadata.custom) {
+            for (const [key, value] of Object.entries(metadata.custom)) {
+                chunks.push(this.createChunk("tEXt", this.createTextChunk(key, String(value))));
+            }
+        }
+        // Add EXIF chunk for GPS data and creation date
+        if (metadata.latitude !== undefined || metadata.longitude !== undefined ||
+            metadata.creationDate !== undefined) {
+            const exifChunk = this.createExifChunk(metadata);
+            if (exifChunk) {
+                chunks.push(this.createChunk("eXIf", exifChunk));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+import type { ImageData, ImageFormat } from "../types.js";
+/**
+ * PPM format handler
+ * Implements the Netpbm PPM (Portable PixMap) format.
+ * This is a simple uncompressed RGB format supported by many image tools.
+ *
+ * Format structure:
+ * - P3 (ASCII format):
+ *   P3
+ *   <width> <height>
+ *   <maxval>
+ *   R G B R G B ... (space-separated decimal values)
+ *
+ * - P6 (Binary format):
+ *   P6
+ *   <width> <height>
+ *   <maxval>
+ *   RGB RGB RGB ... (binary byte data)
+ */
+export declare class PPMFormat implements ImageFormat {
+    /** Format name identifier */
+    readonly name = "ppm";
+    /** MIME type for PPM images */
+    readonly mimeType = "image/x-portable-pixmap";
+    /**
+     * Check if the given data is a PPM image
+     * @param data Raw image data to check
+     * @returns true if data has PPM signature (P3 or P6)
+     */
+    canDecode(data: Uint8Array): boolean;
+    /**
+     * Decode PPM image data to RGBA
+     * Supports both P3 (ASCII) and P6 (binary) formats
+     * @param data Raw PPM image data
+     * @returns Decoded image data with RGBA pixels
+     */
+    decode(data: Uint8Array): 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>;
+    /**
+     * Check if a byte is whitespace (space, tab, CR, LF)
+     */
+    private isWhitespace;
+}
+//# sourceMappingURL=ppm.d.ts.map