@woosh/meep-engine 2.138.13 → 2.138.16

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

@@ -7,30 +7,18 @@ 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 { png_chunk_decode_iTXt } from "./chunk/png_chunk_decode_iTXt.js";
+import { png_chunk_decode_zTXt } from "./chunk/png_chunk_decode_zTXt.js";
 import { crc32 } from "./crc32.js";
+import { png_filter_unFilterAverage } from "./filter/png_filter_unFilterAverage.js";
+import { png_filter_unFilterNone } from "./filter/png_filter_unFilterNone.js";
+import { png_filter_unFilterPaeth } from "./filter/png_filter_unFilterPaeth.js";
+import { png_filter_unFilterSub } from "./filter/png_filter_unFilterSub.js";
+import { png_filter_unFilterUp } from "./filter/png_filter_unFilterUp.js";
 
 import { PNG } from './PNG.js';
 import { PNG_HEADER_BYTES } from "./PNG_HEADER_BYTES.js";
 
-/**
- *
- * @param {Uint8Array} encoded_chunk
- * @returns {ArrayBuffer}
- */
-function inflate(encoded_chunk) {
-    const inflator = new zlib.Inflate();
-
-
-    inflator.push(encoded_chunk);
-
-    if (inflator.err) {
-        throw new Error(inflator.err);
-    }
-
-
-    return inflator.result.buffer;
-}
-
 /**
  *
  * @param {Uint8Array} buffer
@@ -221,10 +209,10 @@ PNGReader.prototype.decodeChunk = function () {
             this.decodetIME(chunk);
             break;
         case 'zTXt':
-            this.decodezTXt(chunk);
+            png_chunk_decode_zTXt(chunk);
             break;
         case 'iTXt':
-            this.decodeiTXt(chunk);
+            png_chunk_decode_iTXt(chunk);
             break;
         default:
             // skip unknown block
@@ -265,89 +253,6 @@ PNGReader.prototype.decodetIME = function (chunk) {
     const second = readUInt8(chunk, 6);
 }
 
-/**
- * International textual data
- * @see https://www.w3.org/TR/2003/REC-PNG-20031110/
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodeiTXt = function (chunk) {
-    const buffer = BinaryBuffer.fromArrayBuffer(chunk.buffer);
-    const keyword = buffer.readASCIICharacters(79, true);
-    const compression_flag = buffer.readUint8();
-    const compression_method = buffer.readUint8();
-
-
-    const language_tag = buffer.readASCIICharacters(Infinity, true);
-    const translated_keyword = buffer.readASCIICharacters(Infinity, true);
-
-    const remaining_bytes = buffer.data.length - buffer.position;
-
-    let text;
-
-    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);
-
-        text = buffer.readASCIICharacters(decoded.byteLength);
-    } else {
-        throw new Error(`Invalid compression flag value '${compression_flag}'`);
-    }
-
-    return {
-        keyword,
-        language_tag,
-        translated_keyword,
-        text
-    }
-}
-
-
-/**
- * Compressed textual data
- * @see https://www.w3.org/TR/2003/REC-PNG-20031110/#11zTXt
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodezTXt = function (chunk) {
-    const buffer = BinaryBuffer.fromArrayBuffer(chunk.buffer);
-
-    const keyword = buffer.readASCIICharacters(79, true);
-
-    const compression_method = buffer.readUint8();
-
-    let value;
-
-    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);
-
-        buffer.fromArrayBuffer(decompressed_data);
-
-        value = buffer.readASCIICharacters(decompressed_data.length);
-    } else {
-        throw new Error(`Unsupported compression method '${compression_method}'`);
-    }
-
-    return {
-        keyword: keyword,
-        text: value
-    }
-}
-
 /**
  * https://www.w3.org/TR/PNG/#11tEXt
  * @param {Uint8Array} chunk
@@ -473,6 +378,18 @@ PNGReader.prototype.decodePixels = function () {
     } else {
         this.png.pixels = this.interlaceAdam7(decompressed_data);
     }
+
+    // PNG stores 16-bit samples big-endian. Rewrite the buffer to platform-endian
+    // here so that downstream consumers can view it as Uint16Array without further
+    // byte swapping.
+    if (png.bitDepth === 16 && platform_compute_endianness() === EndianType.LittleEndian) {
+        const pixels = this.png.pixels;
+        for (let i = 0; i < pixels.length; i += 2) {
+            const hi = pixels[i];
+            pixels[i] = pixels[i + 1];
+            pixels[i + 1] = hi;
+        }
+    }
 };
 
 // Different interlace methods
@@ -513,7 +430,7 @@ PNGReader.prototype.interlaceNone = function (data) {
             data,
             scanline_address,
             pixels,
-            depth,
+            Math.max(1, Math.ceil(bytes_per_pixel)),
             offset,
             offset - color_bytes_per_row,
             color_bytes_per_row
@@ -536,8 +453,7 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
 
     const png = this.png;
 
-    const depth = png.bitDepth;
-    const bytes_per_pixel = png.colors * depth / 8;
+    const bytes_per_pixel = png.colors * png.bitDepth / 8;
 
     const pixels = new Uint8Array(bytes_per_pixel * png.width * png.height);
 
@@ -619,27 +535,7 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
         }
     }
 
-    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;
-    }
-
+    return pixels;
 };
 
 // Unfiltering
@@ -675,40 +571,37 @@ PNGReader.prototype.unFilter = function (
 
     switch (filter_type) {
         case 0:
-            this.unFilterNone(
+            png_filter_unFilterNone(
                 data,
                 scanline_address,
                 output,
-                bytes_per_pixel,
                 output_offset,
-                output_offset_previous,
-                length
+                length,
+                this.png.bitDepth
             );
             break;
         case 1:
-            this.unFilterSub(
+            png_filter_unFilterSub(
                 data,
                 scanline_address,
                 output,
                 bytes_per_pixel,
                 output_offset,
-                output_offset_previous,
                 length
             );
             break;
         case 2:
-            this.unFilterUp(
+            png_filter_unFilterUp(
                 data,
                 scanline_address,
                 output,
-                bytes_per_pixel,
                 output_offset,
                 output_offset_previous,
                 length
             );
             break;
         case 3:
-            this.unFilterAverage(
+            png_filter_unFilterAverage(
                 data,
                 scanline_address,
                 output,
@@ -719,7 +612,7 @@ PNGReader.prototype.unFilter = function (
             );
             break;
         case 4:
-            this.unFilterPaeth(
+            png_filter_unFilterPaeth(
                 data,
                 scanline_address,
                 output,
@@ -734,288 +627,6 @@ PNGReader.prototype.unFilter = function (
     }
 }
 
-/**
- * With the None filter, the scanline is transmitted unmodified; it is only necessary to insert a filter type byte before the data.
- *
- * @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
- *
- * @see https://www.w3.org/TR/PNG-Filters.html
- */
-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
- * @see https://www.w3.org/TR/PNG-Filters.html
- */
-PNGReader.prototype.unFilterSub = function (
-    scanline,
-    scanline_offset,
-    pixels,
-    bpp,
-    offset,
-    output_offset_previous,
-    length
-) {
-
-    let i = 0;
-
-    for (; i < bpp; i++) {
-        pixels[offset + i] = scanline[i + scanline_offset];
-    }
-
-    for (; i < length; i++) {
-        // Raw(x) + Raw(x - bpp)
-        const of_i = offset + i;
-        pixels[of_i] = (scanline[i + scanline_offset] + pixels[of_i - bpp]) & 0xFF;
-    }
-
-};
-
-/**
- * The `Up` filter is just like the Sub() filter except that the pixel
- * 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
- * @see https://www.w3.org/TR/PNG-Filters.html
- */
-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 (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;
-        }
-
-    }
-};
-
-/**
- * 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
- *
- * @see https://www.w3.org/TR/PNG-Filters.html
- */
-PNGReader.prototype.unFilterAverage = function (
-    scanline,
-    scanline_offset,
-    pixels,
-    bpp,
-    offset,
-    output_offset_previous,
-    length
-) {
-    let i = 0, byte, prev, prior;
-
-    if (output_offset_previous < 0) {
-
-        // Prior(x) == 0 && Raw(x - bpp) == 0
-        for (; i < bpp; i++) {
-            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 = 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++) {
-            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];
-
-            prev = pixels[offset + i - bpp];
-            prior = pixels[output_offset_previous + i];
-
-            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.
- *
- * @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
- *
- * @see https://www.w3.org/TR/PNG-Filters.html
- */
-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 (output_offset_previous < 0) {
-
-        // Prior(x) == 0 && Raw(x - bpp) == 0
-        for (; i < bpp; i++) {
-            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[offset + i] = (scanline[i + scanline_offset] + pixels[offset + i - bpp]) & 0xFF;
-        }
-
-    } else {
-
-        // Prior(x) != 0 && Raw(x - bpp) == 0
-        // paethPredictor(x, 0, 0) is always x
-        for (; i < bpp; i++) {
-            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];
-
-            c = pixels[output_offset_previous + i - bpp];
-            b = pixels[output_offset_previous + i];
-            a = pixels[offset + i - bpp];
-
-            p = a + b - c;
-
-            pa = Math.abs(p - a);
-            pb = Math.abs(p - b);
-            pc = Math.abs(p - c);
-
-            if (pa <= pb && pa <= pc) {
-                pr = a;
-            } else if (pb <= pc) {
-                pr = b;
-            } else {
-                pr = c;
-            }
-
-            pixels[offset + i] = (raw + pr) & 0xFF;
-        }
-
-    }
-};
-
 /**
  * Parse the PNG file
  * @returns {PNG}

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_iTXt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * International textual data
+ * @see https://www.w3.org/TR/2003/REC-PNG-20031110/
+ * @param {Uint8Array} chunk
+ */
+export function png_chunk_decode_iTXt(chunk: Uint8Array): {
+    keyword: string;
+    language_tag: string;
+    translated_keyword: string;
+    text: string;
+};
+//# sourceMappingURL=png_chunk_decode_iTXt.d.ts.map

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_iTXt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_chunk_decode_iTXt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/chunk/png_chunk_decode_iTXt.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,6CAFW,UAAU;;;;;EA8CpB"}

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_iTXt.js

@@ -0,0 +1,53 @@
+import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
+import { inflate } from "../inflate.js";
+
+/**
+ * International textual data
+ * @see https://www.w3.org/TR/2003/REC-PNG-20031110/
+ * @param {Uint8Array} chunk
+ */
+export function png_chunk_decode_iTXt(chunk) {
+    const chunk_size = chunk.byteLength;
+    const chunk_buffer = chunk.buffer;
+    const chunk_byte_offset = chunk.byteOffset;
+    const chunk_byte_end = chunk_byte_offset + chunk_size;
+
+    const buffer = BinaryBuffer.fromArrayBuffer(chunk_buffer);
+    buffer.position = chunk_byte_offset;
+
+    const keyword = buffer.readASCIICharacters(79, true);
+    const compression_flag = buffer.readUint8();
+    const compression_method = buffer.readUint8();
+
+
+    const language_tag = buffer.readASCIICharacters(Number.MAX_SAFE_INTEGER, true);
+    const translated_keyword = buffer.readASCIICharacters(Number.MAX_SAFE_INTEGER, true);
+
+    const remaining_bytes = chunk_byte_end - buffer.position;
+
+    let text;
+
+    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);
+
+        text = buffer.readASCIICharacters(decoded.byteLength);
+    } else {
+        throw new Error(`Invalid compression flag value '${compression_flag}'`);
+    }
+
+    return {
+        keyword,
+        language_tag,
+        translated_keyword,
+        text
+    }
+}

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_zTXt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compressed textual data
+ * @see https://www.w3.org/TR/2003/REC-PNG-20031110/#11zTXt
+ * @param {Uint8Array} chunk
+ */
+export function png_chunk_decode_zTXt(chunk: Uint8Array): {
+    keyword: string;
+    text: string;
+};
+//# sourceMappingURL=png_chunk_decode_zTXt.d.ts.map

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_zTXt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_chunk_decode_zTXt.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/chunk/png_chunk_decode_zTXt.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,6CAFW,UAAU;;;EAmCpB"}

package/src/engine/asset/loaders/image/png/chunk/png_chunk_decode_zTXt.js

@@ -0,0 +1,42 @@
+import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
+import { inflate } from "../inflate.js";
+
+/**
+ * Compressed textual data
+ * @see https://www.w3.org/TR/2003/REC-PNG-20031110/#11zTXt
+ * @param {Uint8Array} chunk
+ */
+export function png_chunk_decode_zTXt(chunk) {
+    const chunk_size = chunk.byteLength;
+    const chunk_buffer = chunk.buffer;
+    const chunk_byte_offset = chunk.byteOffset;
+
+    const buffer = BinaryBuffer.fromArrayBuffer(chunk_buffer);
+    buffer.position = chunk_byte_offset;
+
+    const keyword = buffer.readASCIICharacters(79, true);
+
+    const compression_method = buffer.readUint8();
+
+    let value;
+
+    if (compression_method === 0) {
+        // deflate method
+
+        const local_offset = buffer.position - chunk_byte_offset;
+        const encoded_chunk = new Uint8Array(chunk_buffer, buffer.position, chunk_size  - local_offset);
+
+        const decompressed_data = inflate(encoded_chunk);
+
+        buffer.fromArrayBuffer(decompressed_data);
+
+        value = buffer.readASCIICharacters(decompressed_data.byteLength);
+    } else {
+        throw new Error(`Unsupported compression method '${compression_method}'`);
+    }
+
+    return {
+        keyword: keyword,
+        text: value
+    }
+}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterAverage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 pass a negative value when there is no previous scanline
+ * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterAverage(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterAverage.d.ts.map

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterAverage.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/filter/png_filter_unFilterAverage.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qDAVW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA8ChB"}