@woosh/meep-engine 2.126.75 → 2.127.1

package/src/engine/asset/loaders/image/png/PNGReader.js

@@ -2,8 +2,10 @@
 "use strict";
 
 import zlib from 'pako';
+import { assert } from "../../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { EndianType } from "../../../../../core/binary/EndianType.js";
+import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
 import { crc32 } from "./crc32.js";
 
@@ -77,6 +79,10 @@ export function PNGReader(bytes) {
      */
     this.png = new PNG();
 
+    /**
+     *
+     * @type {Uint8Array[]}
+     */
     this.dataChunks = [];
 
     /**
@@ -109,11 +115,16 @@ export function PNGReader(bytes) {
  * @return {Uint8Array}
  */
 PNGReader.prototype.readBytes = function (length) {
-    const result = new Uint8Array(length);
 
-    this.buffer.readBytes(result, 0, length);
+    const buffer = this.buffer;
+
+    // Reference instead of a copy
+    const result = new Uint8Array(buffer.data, buffer.position, length);
+
+    buffer.skip(length);
 
     return result;
+
 };
 
 /**
@@ -265,6 +276,7 @@ PNGReader.prototype.decodeiTXt = function (chunk) {
     const compression_flag = buffer.readUint8();
     const compression_method = buffer.readUint8();
 
+
     const language_tag = buffer.readASCIICharacters(Infinity, true);
     const translated_keyword = buffer.readASCIICharacters(Infinity, true);
 
@@ -275,6 +287,11 @@ PNGReader.prototype.decodeiTXt = function (chunk) {
     if (compression_flag === 0) {
         text = buffer.readASCIICharacters(remaining_bytes);
     } else if (compression_flag === 1) {
+
+        if(compression_method !== 0){
+            throw new Error('only compression_method 0 is supported');
+        }
+
         const decoded = inflate(new Uint8Array(buffer.data, buffer.position, remaining_bytes));
 
         buffer.fromArrayBuffer(decoded);
@@ -310,6 +327,10 @@ PNGReader.prototype.decodezTXt = function (chunk) {
     if (compression_method === 0) {
         // deflate method
 
+        if(compression_method !== 0){
+            throw new Error('only compression_method 0 is supported');
+        }
+
         const encoded_chunk = new Uint8Array(chunk.buffer, buffer.position);
 
         const decompressed_data = inflate(encoded_chunk);
@@ -351,6 +372,9 @@ PNGReader.prototype.decodeiEXt = function (chunk) {
 
     const compression_flag = buff.readUint8();
     const compression_method = buff.readUint8();
+
+    // TODO process compression properly
+
     const language_tag = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
     const translated_keyword = buff.readUTF8String();
 
@@ -393,6 +417,7 @@ PNGReader.prototype.decodeIHDR = function (chunk) {
 /**
  *
  * http://www.w3.org/TR/PNG/#11PLTE
+ * @param {Uint8Array} chunk
  */
 PNGReader.prototype.decodePLTE = function (chunk) {
     this.png.setPalette(chunk);
@@ -411,7 +436,7 @@ PNGReader.prototype.decodeIDAT = function (chunk) {
  * @param {Uint8Array} chunk
  */
 PNGReader.prototype.decodeTRNS = function (chunk) {
-    this.png.setTRNS(chunk);
+    this.png.transparency_lookup = chunk;
 };
 
 /**
@@ -442,10 +467,11 @@ PNGReader.prototype.decodePixels = function () {
 
     const decompressed_data = inflator.result;
 
+    // https://www.w3.org/TR/png-3/#8InterlaceMethods
     if (png.getInterlaceMethod() === 0) {
-        this.interlaceNone(decompressed_data);
+        this.png.pixels = this.interlaceNone(decompressed_data);
     } else {
-        this.interlaceAdam7(decompressed_data);
+        this.png.pixels = this.interlaceAdam7(decompressed_data);
     }
 };
 
@@ -468,9 +494,7 @@ PNGReader.prototype.interlaceNone = function (data) {
     // color bytes per row
     const color_bytes_per_row = Math.ceil(bytes_per_pixel * width);
 
-    const output_bytes_per_row = Math.ceil(bytes_per_pixel) * width;
-
-    const pixels = new Uint8Array(output_bytes_per_row * height);
+    const pixels = new Uint8Array(color_bytes_per_row * height);
 
     let offset = 0;
 
@@ -482,95 +506,324 @@ PNGReader.prototype.interlaceNone = function (data) {
 
         // scanline = slice.call(data, scanline_address, scanline_address + cpr);
 
-        const header = readUInt8(data, i);
-
-        switch (header) {
-            case 0:
-                // NONE
-                if (depth === 1) {
-                    for (let x = 0; x < output_bytes_per_row; x++) {
-                        const q = x >>> 4;
-                        const datum = data[q + scanline_address];
-                        const shift = ((x) & 0x7);
-                        const out_value = (datum >>> shift) & 0x1;
-                        pixels[offset + x] = out_value;
-                    }
-                } else if (depth === 2) {
-                    for (let x = 0; x < output_bytes_per_row; x++) {
-                        const q = x >>> 2;
-                        const datum = data[q + scanline_address];
-                        const shift = ((~x) & 0x3) << 1;
-                        const out_value = (datum >>> shift) & 0x3;
-                        pixels[offset + x] = out_value;
-                    }
-                } else if (depth === 4) {
-                    for (let x = 0; x < output_bytes_per_row; x++) {
-                        const q = x >>> 1;
-                        const datum = data[q + scanline_address];
-                        const shift = ((~x) & 0x1) << 2;
-                        const out_value = (datum >>> shift) & 0xF;
-                        pixels[offset + x] = out_value;
-                    }
-                } else if (depth === 8) {
-                    for (let x = 0; x < output_bytes_per_row; x++) {
-                        pixels[offset + x] = data[x + scanline_address];
-                    }
-                } else {
-                    throw new Error(`unsupported bit depth ${depth}`)
-                }
-                break;
-            case 1:
-                this.unFilterSub(data, scanline_address, pixels, bytes_per_pixel, offset, color_bytes_per_row);
-                break;
-            case 2:
-                this.unFilterUp(data, scanline_address, pixels, bytes_per_pixel, offset, color_bytes_per_row);
-                break;
-            case 3:
-                this.unFilterAverage(data, scanline_address, pixels, bytes_per_pixel, offset, color_bytes_per_row);
-                break;
-            case 4:
-                this.unFilterPaeth(data, scanline_address, pixels, bytes_per_pixel, offset, color_bytes_per_row);
-                break;
-            default:
-                throw new Error(`unknown filtered scanline type '${header}'`);
-        }
+        const filter_type = readUInt8(data, i);
+
+        this.unFilter(
+            filter_type,
+            data,
+            scanline_address,
+            pixels,
+            depth,
+            offset,
+            offset - color_bytes_per_row,
+            color_bytes_per_row
+        );
 
-        offset += output_bytes_per_row;
+        offset += color_bytes_per_row;
 
     }
 
-    png.pixels = pixels;
+    return pixels;
 
 };
 
+
 /**
  * De-interlace image according to Adam 7 scheme
  * @param {Uint8Array} data
  */
 PNGReader.prototype.interlaceAdam7 = function (data) {
-    throw new Error("Adam7 interlacing is not implemented yet");
+
+    const png = this.png;
+
+    const depth = png.bitDepth;
+    const bytes_per_pixel = png.colors * depth / 8;
+
+    const pixels = new Uint8Array(bytes_per_pixel * png.width * png.height);
+
+    // Adam7 interlacing pattern
+    const passes = [
+        { x: 0, y: 0, xStep: 8, yStep: 8 }, // Pass 1
+        { x: 4, y: 0, xStep: 8, yStep: 8 }, // Pass 2
+        { x: 0, y: 4, xStep: 4, yStep: 8 }, // Pass 3
+        { x: 2, y: 0, xStep: 4, yStep: 4 }, // Pass 4
+        { x: 0, y: 2, xStep: 2, yStep: 4 }, // Pass 5
+        { x: 1, y: 0, xStep: 2, yStep: 2 }, // Pass 6
+        { x: 0, y: 1, xStep: 1, yStep: 2 }, // Pass 7
+    ];
+
+    const width = png.width;
+    const height = png.height;
+
+    let offset = 0;
+
+    // Create a new line for the unfiltered data
+    const line_bytes_buffer = new Uint8Array(width * bytes_per_pixel);
+
+    // Process each pass
+    for (let passIndex = 0; passIndex < 7; passIndex++) {
+        const pass = passes[passIndex];
+
+        // Calculate pass dimensions
+        const pass_width = Math.ceil((width - pass.x) / pass.xStep);
+        const pass_height = Math.ceil((height - pass.y) / pass.yStep);
+
+        if (pass_width <= 0 || pass_height <= 0) {
+            continue;
+        }
+
+        const passLineBytes = pass_width * bytes_per_pixel;
+
+        // Indicate to unfiltering that this is the first line (no previous line)
+        let previous_line_offset = -1;
+
+        // Process each scanline in this pass
+        for (let y = 0; y < pass_height; y++) {
+
+            // First byte is the filter type
+            const filter_type = data[offset++];
+
+            // we use alternating line offsets to save on memory allocations
+            const line_offset = (y % 2) * passLineBytes;
+
+            // Apply the appropriate unfilter
+            this.unFilter(
+                filter_type,
+                data,
+                offset,
+                line_bytes_buffer,
+                bytes_per_pixel,
+                line_offset,
+                previous_line_offset,
+                passLineBytes,
+            );
+
+            offset += passLineBytes;
+            previous_line_offset = line_offset;
+
+            for (let x = 0; x < pass_width; x++) {
+
+                const outputX = pass.x + x * pass.xStep;
+                const outputY = pass.y + y * pass.yStep;
+
+                if (outputX >= width || outputY >= height) {
+                    continue;
+                }
+
+                for (let i = 0; i < bytes_per_pixel; i++) {
+                    const out_offset = (outputY * width + outputX) * bytes_per_pixel + i;
+
+                    pixels[out_offset] = line_bytes_buffer[line_offset + x * bytes_per_pixel + i];
+                }
+            }
+        }
+    }
+
+    function swap16(val) {
+        return ((val & 0xff) << 8) | ((val >> 8) & 0xff);
+    }
+
+    if (depth === 16) {
+        const uint16Data = new Uint16Array(pixels.buffer);
+
+        const osIsLittleEndian = platform_compute_endianness() === EndianType.LittleEndian;
+
+        if (osIsLittleEndian) {
+            for (let k = 0; k < uint16Data.length; k++) {
+                // PNG is always big endian. Swap the bytes.
+                uint16Data[k] = swap16(uint16Data[k]);
+            }
+        }
+
+        return uint16Data;
+    } else {
+        return pixels;
+    }
+
 };
 
 // Unfiltering
 
+/**
+ *
+ * @param {number} filter_type
+ * @param {Uint8Array} data
+ * @param {number} scanline_address
+ * @param {Uint8Array} output
+ * @param {number} bytes_per_pixel
+ * @param {number} output_offset
+ * @param {number} output_offset_previous where does result of previous scanline begin in the output? Needed for various filters such as `Up`
+ * @param {number} length
+ */
+PNGReader.prototype.unFilter = function (
+    filter_type,
+    data,
+    scanline_address,
+    output,
+    bytes_per_pixel,
+    output_offset,
+    output_offset_previous,
+    length
+) {
+    assert.isInteger(filter_type, 'filter_type');
+    assert.isNonNegativeInteger(scanline_address, 'scanline_address');
+    assert.isNonNegativeInteger(bytes_per_pixel, 'bytes_per_pixel');
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+    assert.isNonNegativeInteger(length, 'length');
+
+    switch (filter_type) {
+        case 0:
+            this.unFilterNone(
+                data,
+                scanline_address,
+                output,
+                bytes_per_pixel,
+                output_offset,
+                output_offset_previous,
+                length
+            );
+            break;
+        case 1:
+            this.unFilterSub(
+                data,
+                scanline_address,
+                output,
+                bytes_per_pixel,
+                output_offset,
+                output_offset_previous,
+                length
+            );
+            break;
+        case 2:
+            this.unFilterUp(
+                data,
+                scanline_address,
+                output,
+                bytes_per_pixel,
+                output_offset,
+                output_offset_previous,
+                length
+            );
+            break;
+        case 3:
+            this.unFilterAverage(
+                data,
+                scanline_address,
+                output,
+                bytes_per_pixel,
+                output_offset,
+                output_offset_previous,
+                length
+            );
+            break;
+        case 4:
+            this.unFilterPaeth(
+                data,
+                scanline_address,
+                output,
+                bytes_per_pixel,
+                output_offset,
+                output_offset_previous,
+                length
+            );
+            break;
+        default:
+            throw new Error(`unknown filtered scanline type '${filter_type}'`);
+    }
+}
+
+/**
+ *
+ * @param {Uint8Array} data
+ * @param {number} scanline_address
+ * @param {Uint8Array} output
+ * @param {number} bytes_per_pixel
+ * @param {number} output_offset
+ * @param {number} output_offset_previous
+ * @param {number} length
+ */
+PNGReader.prototype.unFilterNone = function (
+    data,
+    scanline_address,
+    output,
+    bytes_per_pixel,
+    output_offset,
+    output_offset_previous,
+    length
+) {
+
+    const png = this.png;
+    const depth = png.bitDepth;
+
+    if (depth === 1) {
+        for (let x = 0; x < length; x++) {
+            const q = x >>> 4;
+            const datum = data[q + scanline_address];
+            const shift = ((x) & 0x7);
+            const out_value = (datum >>> shift) & 0x1;
+            output[output_offset + x] = out_value;
+        }
+    } else if (depth === 2) {
+        for (let x = 0; x < length; x++) {
+            const q = x >>> 2;
+            const datum = data[q + scanline_address];
+            const shift = ((~x) & 0x3) << 1;
+            const out_value = (datum >>> shift) & 0x3;
+            output[output_offset + x] = out_value;
+        }
+    } else if (depth === 4) {
+        for (let x = 0; x < length; x++) {
+            const q = x >>> 1;
+            const datum = data[q + scanline_address];
+            const shift = ((~x) & 0x1) << 2;
+            const out_value = (datum >>> shift) & 0xF;
+            output[output_offset + x] = out_value;
+        }
+    } else if (depth === 8) {
+        for (let x = 0; x < length; x++) {
+            // straight copy
+            output[output_offset + x] = data[x + scanline_address];
+        }
+    } else {
+        throw new Error(`unsupported bit depth ${depth}`)
+    }
+};
 
 /**
  * The Sub() filter transmits the difference between each byte and the value
  * of the corresponding byte of the prior pixel.
  * Sub(x) = Raw(x) + Raw(x - bpp)
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous
+ * @param {number} length
  */
-PNGReader.prototype.unFilterSub = function (scanline, scanline_offset, pixels, bpp, of, length) {
+PNGReader.prototype.unFilterSub = function (
+    scanline,
+    scanline_offset,
+    pixels,
+    bpp,
+    offset,
+    output_offset_previous,
+    length
+) {
+
     let i = 0;
 
     for (; i < bpp; i++) {
-        pixels[of + i] = scanline[i + scanline_offset];
+        pixels[offset + i] = scanline[i + scanline_offset];
     }
 
     for (; i < length; i++) {
         // Raw(x) + Raw(x - bpp)
-        const of_i = of + i;
+        const of_i = offset + i;
         pixels[of_i] = (scanline[i + scanline_offset] + pixels[of_i - bpp]) & 0xFF;
     }
+
 };
 
 /**
@@ -578,18 +831,46 @@ PNGReader.prototype.unFilterSub = function (scanline, scanline_offset, pixels, b
  * immediately above the current pixel, rather than just to its left, is used
  * as the predictor.
  * Up(x) = Raw(x) + Prior(x)
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous
+ * @param {number} length
  */
-PNGReader.prototype.unFilterUp = function (scanline, scanline_offset, pixels, bpp, of, length) {
+PNGReader.prototype.unFilterUp = function (
+    scanline,
+    scanline_offset,
+    pixels,
+    bpp,
+    offset,
+    output_offset_previous,
+    length
+) {
     let i = 0, byte, prev;
+
     // Prior(x) is 0 for all x on the first scanline
-    if ((of - length) < 0) for (; i < length; i++) {
-        pixels[of + i] = scanline[i + scanline_offset];
-    } else for (; i < length; i++) {
-        // Raw(x)
-        byte = scanline[i + scanline_offset];
-        // Prior(x)
-        prev = pixels[of + i - length];
-        pixels[of + i] = (byte + prev) & 0xFF;
+    if (output_offset_previous < 0) {
+
+        for (; i < length; i++) {
+            pixels[offset + i] = scanline[i + scanline_offset];
+        }
+
+    } else {
+
+        for (; i < length; i++) {
+
+            // Raw(x)
+            byte = scanline[i + scanline_offset];
+
+            // Prior(x)
+            prev = pixels[output_offset_previous + i];
+
+            pixels[offset + i] = (byte + prev) & 0xFF;
+        }
+
     }
 };
 
@@ -597,45 +878,65 @@ PNGReader.prototype.unFilterUp = function (scanline, scanline_offset, pixels, bp
  * The Average() filter uses the average of the two neighboring pixels (left
  * and above) to predict the value of a pixel.
  * Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous
+ * @param {number} length
  */
-PNGReader.prototype.unFilterAverage = function (scanline, scanline_offset, pixels, bpp, of, length) {
+PNGReader.prototype.unFilterAverage = function (
+    scanline,
+    scanline_offset,
+    pixels,
+    bpp,
+    offset,
+    output_offset_previous,
+    length
+) {
     let i = 0, byte, prev, prior;
-    if ((of - length) < 0) {
+
+    if (output_offset_previous < 0) {
+
         // Prior(x) == 0 && Raw(x - bpp) == 0
         for (; i < bpp; i++) {
-            pixels[of + i] = scanline[i + scanline_offset];
+            pixels[offset + i] = scanline[i + scanline_offset];
         }
+
         // Prior(x) == 0 && Raw(x - bpp) != 0 (right shift, prevent doubles)
         for (; i < length; i++) {
-            const of_i = of + i;
+            const of_i = offset + i;
             pixels[of_i] = (scanline[i + scanline_offset] + (pixels[of_i - bpp] >> 1)) & 0xFF;
         }
+
     } else {
+
         // Prior(x) != 0 && Raw(x - bpp) == 0
         for (; i < bpp; i++) {
-            const of_i = of + i;
-
-            pixels[of_i] = (scanline[i + scanline_offset] + (pixels[of_i - length] >> 1)) & 0xFF;
+            pixels[offset + i] = (scanline[i + scanline_offset] + (pixels[output_offset_previous + i] >> 1)) & 0xFF;
         }
+
         // Prior(x) != 0 && Raw(x - bpp) != 0
         for (; i < length; i++) {
             byte = scanline[i + scanline_offset];
 
-            const of_i = of + i;
+            prev = pixels[offset + i - bpp];
+            prior = pixels[output_offset_previous + i];
 
-            prev = pixels[of_i - bpp];
-            prior = pixels[of_i - length];
-
-            pixels[of_i] = (byte + (prev + prior >> 1)) & 0xFF;
+            pixels[offset + i] = (byte + (prev + prior >> 1)) & 0xFF;
         }
+
     }
 };
 
 /**
  * The Paeth() filter computes a simple linear function of the three
  * neighboring pixels (left, above, upper left), then chooses as predictor
- * the neighboring pixel closest to the computed value. This technique is due
- * to Alan W. Paeth.
+ * the neighboring pixel closest to the computed value.
+ * This technique is due to Alan W. Paeth.
+ *
  * Paeth(x) = Raw(x) +
  *            PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp))
  *  function PaethPredictor (a, b, c)
@@ -651,35 +952,54 @@ PNGReader.prototype.unFilterAverage = function (scanline, scanline_offset, pixel
  *       else if pb <= pc then return b
  *       else return c
  *  end
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous
+ * @param {number} length
  */
-PNGReader.prototype.unFilterPaeth = function (scanline, scanline_offset, pixels, bpp, of, length) {
+PNGReader.prototype.unFilterPaeth = function (
+    scanline,
+    scanline_offset,
+    pixels,
+    bpp,
+    offset,
+    output_offset_previous,
+    length
+) {
     let i = 0, raw, a, b, c, p, pa, pb, pc, pr;
-    if ((of - length) < 0) {
+
+    if (output_offset_previous < 0) {
+
         // Prior(x) == 0 && Raw(x - bpp) == 0
         for (; i < bpp; i++) {
-            pixels[of + i] = scanline[i + scanline_offset];
+            pixels[offset + i] = scanline[i + scanline_offset];
         }
+
         // Prior(x) == 0 && Raw(x - bpp) != 0
         // paethPredictor(x, 0, 0) is always x
         for (; i < length; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + pixels[of + i - bpp]) & 0xFF;
+            pixels[offset + i] = (scanline[i + scanline_offset] + pixels[offset + i - bpp]) & 0xFF;
         }
+
     } else {
-        const of1 = of - length;
+
         // Prior(x) != 0 && Raw(x - bpp) == 0
         // paethPredictor(x, 0, 0) is always x
         for (; i < bpp; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + pixels[of1 + i]) & 0xFF;
+            pixels[offset + i] = (scanline[i + scanline_offset] + pixels[output_offset_previous + i]) & 0xFF;
         }
+
         // Prior(x) != 0 && Raw(x - bpp) != 0
         for (; i < length; i++) {
             raw = scanline[i + scanline_offset];
 
-            const offset_0 = of + i;
-
-            c = pixels[offset_0 - length - bpp];
-            b = pixels[offset_0 - length];
-            a = pixels[offset_0 - bpp];
+            c = pixels[output_offset_previous + i - bpp];
+            b = pixels[output_offset_previous + i];
+            a = pixels[offset + i - bpp];
 
             p = a + b - c;
 
@@ -695,8 +1015,9 @@ PNGReader.prototype.unFilterPaeth = function (scanline, scanline_offset, pixels,
                 pr = c;
             }
 
-            pixels[offset_0] = (raw + pr) & 0xFF;
+            pixels[offset + i] = (raw + pr) & 0xFF;
         }
+
     }
 };