@woosh/meep-engine 3.45.0 → 3.46.0

package/src/format/image/png/PNGReader.js

@@ -1,657 +1,657 @@
-/*global Uint8Array:true ArrayBuffer:true */
-"use strict";
-
-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_inflate } from "./png_inflate.js";
-import { png_chunk_decode_zTXt } from "./chunk/png_chunk_decode_zTXt.js";
-import { crc32 } from "../../../core/binary/hash/crc32.js";
-import { png_unfilter } from "./filter/png_unfilter.js";
-import { png_unpack_samples } from "./png_unpack_samples.js";
-
-import { PNG } from './PNG.js';
-import { PNG_HEADER_BYTES } from "./PNG_HEADER_BYTES.js";
-
-/**
- *
- * @param {Uint8Array} buffer
- * @param {number} offset
- * @return {number}
- */
-function readUInt32(buffer, offset) {
-    return (buffer[offset] << 24)
-        | (buffer[offset + 1] << 16)
-        | (buffer[offset + 2] << 8)
-        | (buffer[offset + 3]);
-}
-
-
-/**
- *
- * @param {Uint8Array} buffer
- * @param {number} offset
- * @return {number}
- */
-function readUInt8(buffer, offset) {
-    return buffer[offset];
-}
-
-/**
- *
- * @param {ArrayBuffer} bytes
- * @constructor
- */
-export function PNGReader(bytes) {
-    /**
-     * Output object
-     * @type {PNG}
-     */
-    this.png = new PNG();
-
-    /**
-     *
-     * @type {Uint8Array[]}
-     */
-    this.dataChunks = [];
-
-    /**
-     *
-     * @type {BinaryBuffer}
-     */
-    this.buffer = new BinaryBuffer();
-
-    // see https://www.w3.org/TR/2003/REC-PNG-20031110/#7Integers-and-byte-order
-    this.buffer.endianness = EndianType.BigEndian;
-
-    this.buffer.fromArrayBuffer(bytes);
-
-    /**
-     * Whether CRC should be performed or not
-     * @type {boolean}
-     */
-    this.crc_enabled = false;
-}
-
-/**
- *
- * @param {number} length
- * @return {Uint8Array}
- */
-PNGReader.prototype.readBytes = function (length) {
-
-    const buffer = this.buffer;
-
-    // Reference instead of a copy
-    const result = new Uint8Array(buffer.data, buffer.position, length);
-
-    buffer.skip(length);
-
-    return result;
-
-};
-
-/**
- * http://www.w3.org/TR/2003/REC-PNG-20031110/#5PNG-file-signature
- */
-PNGReader.prototype.decodeHeader = function () {
-
-    const buffer = this.buffer;
-
-    const header = new Uint8Array(PNG_HEADER_BYTES.length);
-
-    buffer.readBytes(header, 0, header.length);
-
-    // see https://www.w3.org/TR/PNG-Structure.html
-    if (!isArrayEqualStrict(header, PNG_HEADER_BYTES)) {
-        throw new Error('invalid PNGReader file (bad signature)');
-    }
-
-
-};
-
-/**
- * http://www.w3.org/TR/2003/REC-PNG-20031110/#5Chunk-layout
- *
- * length =  4      bytes
- * type   =  4      bytes (IHDR, PLTE, IDAT, IEND or others)
- * chunk  =  length bytes
- * crc    =  4      bytes
- *
+/*global Uint8Array:true ArrayBuffer:true */
+"use strict";
+
+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_inflate } from "./png_inflate.js";
+import { png_chunk_decode_zTXt } from "./chunk/png_chunk_decode_zTXt.js";
+import { crc32 } from "../../../core/math/hash/crc32.js";
+import { png_unfilter } from "./filter/png_unfilter.js";
+import { png_unpack_samples } from "./png_unpack_samples.js";
+
+import { PNG } from './PNG.js';
+import { PNG_HEADER_BYTES } from "./PNG_HEADER_BYTES.js";
+
+/**
+ *
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @return {number}
+ */
+function readUInt32(buffer, offset) {
+    return (buffer[offset] << 24)
+        | (buffer[offset + 1] << 16)
+        | (buffer[offset + 2] << 8)
+        | (buffer[offset + 3]);
+}
+
+
+/**
+ *
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @return {number}
+ */
+function readUInt8(buffer, offset) {
+    return buffer[offset];
+}
+
+/**
+ *
+ * @param {ArrayBuffer} bytes
+ * @constructor
+ */
+export function PNGReader(bytes) {
+    /**
+     * Output object
+     * @type {PNG}
+     */
+    this.png = new PNG();
+
+    /**
+     *
+     * @type {Uint8Array[]}
+     */
+    this.dataChunks = [];
+
+    /**
+     *
+     * @type {BinaryBuffer}
+     */
+    this.buffer = new BinaryBuffer();
+
+    // see https://www.w3.org/TR/2003/REC-PNG-20031110/#7Integers-and-byte-order
+    this.buffer.endianness = EndianType.BigEndian;
+
+    this.buffer.fromArrayBuffer(bytes);
+
+    /**
+     * Whether CRC should be performed or not
+     * @type {boolean}
+     */
+    this.crc_enabled = false;
+}
+
+/**
+ *
+ * @param {number} length
+ * @return {Uint8Array}
+ */
+PNGReader.prototype.readBytes = function (length) {
+
+    const buffer = this.buffer;
+
+    // Reference instead of a copy
+    const result = new Uint8Array(buffer.data, buffer.position, length);
+
+    buffer.skip(length);
+
+    return result;
+
+};
+
+/**
+ * http://www.w3.org/TR/2003/REC-PNG-20031110/#5PNG-file-signature
+ */
+PNGReader.prototype.decodeHeader = function () {
+
+    const buffer = this.buffer;
+
+    const header = new Uint8Array(PNG_HEADER_BYTES.length);
+
+    buffer.readBytes(header, 0, header.length);
+
+    // see https://www.w3.org/TR/PNG-Structure.html
+    if (!isArrayEqualStrict(header, PNG_HEADER_BYTES)) {
+        throw new Error('invalid PNGReader file (bad signature)');
+    }
+
+
+};
+
+/**
+ * http://www.w3.org/TR/2003/REC-PNG-20031110/#5Chunk-layout
+ *
+ * length =  4      bytes
+ * type   =  4      bytes (IHDR, PLTE, IDAT, IEND or others)
+ * chunk  =  length bytes
+ * crc    =  4      bytes
+ *
  * @returns {Promise<string>} chunk type, after any compressed metadata has been decoded
- */
+ */
 PNGReader.prototype.decodeChunk = async function () {
-
-    const buffer = this.buffer;
-
-    const length = buffer.readUint32();
-
-    if (length < 0) {
-        throw new Error('Bad chunk length ' + (0xFFFFFFFF & length));
-    }
-
-
-    const chunk_address = buffer.position;
-
-    const type = buffer.readASCIICharacters(4);
-
-    /**
-     *
-     * @type {Uint8Array}
-     */
-    const chunk = this.readBytes(length);
-
-    // checksum
-    const crc_expected = buffer.readUint32();
-
-    if (this.crc_enabled) {
-
-        // NOTE: CRC includes the "type" tag, not just the chunk bytes
-        const crc_actual = crc32(buffer.raw_bytes, chunk_address, length + 4);
-
-        if (crc_actual !== crc_expected) {
-            console.warn(`CRC (Cyclic Redundancy Check) error at block '${type}' at address ${chunk_address}`);
-        }
-
-    }
-
-    // console.log(`chunk: ${type}`);
-
-
-    switch (type) {
-        case 'IHDR':
-            this.decodeIHDR(chunk);
-            break;
-        case 'PLTE':
-            this.decodePLTE(chunk);
-            break;
-        case 'IDAT':
-            this.decodeIDAT(chunk);
-            break;
-        case 'tRNS':
-            this.decodeTRNS(chunk);
-            break;
-        case 'IEND':
-            this.decodeIEND(chunk);
-            break;
-        case 'sRGB':
-            this.decodesRGB(chunk);
-            break;
-        case 'tIME':
-            this.decodetIME(chunk);
-            break;
-        case 'zTXt':
+
+    const buffer = this.buffer;
+
+    const length = buffer.readUint32();
+
+    if (length < 0) {
+        throw new Error('Bad chunk length ' + (0xFFFFFFFF & length));
+    }
+
+
+    const chunk_address = buffer.position;
+
+    const type = buffer.readASCIICharacters(4);
+
+    /**
+     *
+     * @type {Uint8Array}
+     */
+    const chunk = this.readBytes(length);
+
+    // checksum
+    const crc_expected = buffer.readUint32();
+
+    if (this.crc_enabled) {
+
+        // NOTE: CRC includes the "type" tag, not just the chunk bytes
+        const crc_actual = crc32(buffer.raw_bytes, chunk_address, length + 4);
+
+        if (crc_actual !== crc_expected) {
+            console.warn(`CRC (Cyclic Redundancy Check) error at block '${type}' at address ${chunk_address}`);
+        }
+
+    }
+
+    // console.log(`chunk: ${type}`);
+
+
+    switch (type) {
+        case 'IHDR':
+            this.decodeIHDR(chunk);
+            break;
+        case 'PLTE':
+            this.decodePLTE(chunk);
+            break;
+        case 'IDAT':
+            this.decodeIDAT(chunk);
+            break;
+        case 'tRNS':
+            this.decodeTRNS(chunk);
+            break;
+        case 'IEND':
+            this.decodeIEND(chunk);
+            break;
+        case 'sRGB':
+            this.decodesRGB(chunk);
+            break;
+        case 'tIME':
+            this.decodetIME(chunk);
+            break;
+        case 'zTXt':
             await png_chunk_decode_zTXt(chunk);
-            break;
-        case 'iTXt':
+            break;
+        case 'iTXt':
             await png_chunk_decode_iTXt(chunk);
-            break;
-        default:
-            // skip unknown block
-            // console.warn(`Unsupported block ${type}`);
-            break;
-    }
-
-    return type;
-
-};
-
-
-/**
- * https://www.w3.org/TR/2003/REC-PNG-20031110/#11sRGB
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodesRGB = function (chunk) {
-
-    const rendering_intent = readUInt8(chunk, 0);
-
-    // TODO add metadata to the PNG representation
-}
-
-/**
- * https://www.w3.org/TR/2003/REC-PNG-20031110/#11tIME
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodetIME = function (chunk) {
-    const year_high = readUInt8(chunk, 0);
-    const year_low = readUInt8(chunk, 1);
-
-    const year = (year_high << 8) | year_low;
-
-    const month = readUInt8(chunk, 2);
-    const day = readUInt8(chunk, 3);
-    const hour = readUInt8(chunk, 4);
-    const minute = readUInt8(chunk, 5);
-    const second = readUInt8(chunk, 6);
-}
-
-/**
- * https://www.w3.org/TR/PNG/#11tEXt
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodetEXt = function (chunk) {
-    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
-    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
-
-    const value = buff.readASCIICharacters(keyword.length - 1, false);
-
-    this.png.text[keyword] = value;
-}
-/**
- * NOTE: untested
- * https://www.w3.org/TR/PNG/#11iEXt
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodeiEXt = function (chunk) {
-    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
-
-    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
-
-    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();
-
-    const separator = buff.readUint8();
-
-    if (separator !== 0) {
-        throw new Error('Expected Null Separator after Translated keyword');
-    }
-
-    const text = buff.readUTF8String();
-
-    this.png.text[keyword] = text;
-}
-
-/**
- * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IHDR
- * http://www.libpng.org/pub/png/spec/1.2/png-1.2-pdg.html#C.IHDR
- *
- * Width               4 bytes
- * Height              4 bytes
- * Bit depth           1 byte
- * Colour type         1 byte
- * Compression method  1 byte
- * Filter method       1 byte
- * Interlace method    1 byte
- */
-PNGReader.prototype.decodeIHDR = function (chunk) {
-    const png = this.png;
-
-    png.setWidth(readUInt32(chunk, 0));
-    png.setHeight(readUInt32(chunk, 4));
-    png.setBitDepth(readUInt8(chunk, 8));
-    png.setColorType(readUInt8(chunk, 9));
-    png.setCompressionMethod(readUInt8(chunk, 10));
-    png.setFilterMethod(readUInt8(chunk, 11));
-    png.setInterlaceMethod(readUInt8(chunk, 12));
-
-};
-
-/**
- *
- * http://www.w3.org/TR/PNG/#11PLTE
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodePLTE = function (chunk) {
-    this.png.setPalette(chunk);
-};
-
-/**
- * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IDAT
- */
-PNGReader.prototype.decodeIDAT = function (chunk) {
-    // multiple IDAT chunks will concatenated
-    this.dataChunks.push(chunk);
-};
-
-/**
- * https://www.w3.org/TR/PNG/#11tRNS
- * @param {Uint8Array} chunk
- */
-PNGReader.prototype.decodeTRNS = function (chunk) {
-    this.png.transparency_lookup = chunk;
-};
-
-/**
- * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IEND
- */
-PNGReader.prototype.decodeIEND = function () {
-};
-
-/**
+            break;
+        default:
+            // skip unknown block
+            // console.warn(`Unsupported block ${type}`);
+            break;
+    }
+
+    return type;
+
+};
+
+
+/**
+ * https://www.w3.org/TR/2003/REC-PNG-20031110/#11sRGB
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodesRGB = function (chunk) {
+
+    const rendering_intent = readUInt8(chunk, 0);
+
+    // TODO add metadata to the PNG representation
+}
+
+/**
+ * https://www.w3.org/TR/2003/REC-PNG-20031110/#11tIME
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodetIME = function (chunk) {
+    const year_high = readUInt8(chunk, 0);
+    const year_low = readUInt8(chunk, 1);
+
+    const year = (year_high << 8) | year_low;
+
+    const month = readUInt8(chunk, 2);
+    const day = readUInt8(chunk, 3);
+    const hour = readUInt8(chunk, 4);
+    const minute = readUInt8(chunk, 5);
+    const second = readUInt8(chunk, 6);
+}
+
+/**
+ * https://www.w3.org/TR/PNG/#11tEXt
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodetEXt = function (chunk) {
+    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
+    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+
+    const value = buff.readASCIICharacters(keyword.length - 1, false);
+
+    this.png.text[keyword] = value;
+}
+/**
+ * NOTE: untested
+ * https://www.w3.org/TR/PNG/#11iEXt
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodeiEXt = function (chunk) {
+    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
+
+    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+
+    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();
+
+    const separator = buff.readUint8();
+
+    if (separator !== 0) {
+        throw new Error('Expected Null Separator after Translated keyword');
+    }
+
+    const text = buff.readUTF8String();
+
+    this.png.text[keyword] = text;
+}
+
+/**
+ * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IHDR
+ * http://www.libpng.org/pub/png/spec/1.2/png-1.2-pdg.html#C.IHDR
+ *
+ * Width               4 bytes
+ * Height              4 bytes
+ * Bit depth           1 byte
+ * Colour type         1 byte
+ * Compression method  1 byte
+ * Filter method       1 byte
+ * Interlace method    1 byte
+ */
+PNGReader.prototype.decodeIHDR = function (chunk) {
+    const png = this.png;
+
+    png.setWidth(readUInt32(chunk, 0));
+    png.setHeight(readUInt32(chunk, 4));
+    png.setBitDepth(readUInt8(chunk, 8));
+    png.setColorType(readUInt8(chunk, 9));
+    png.setCompressionMethod(readUInt8(chunk, 10));
+    png.setFilterMethod(readUInt8(chunk, 11));
+    png.setInterlaceMethod(readUInt8(chunk, 12));
+
+};
+
+/**
+ *
+ * http://www.w3.org/TR/PNG/#11PLTE
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodePLTE = function (chunk) {
+    this.png.setPalette(chunk);
+};
+
+/**
+ * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IDAT
+ */
+PNGReader.prototype.decodeIDAT = function (chunk) {
+    // multiple IDAT chunks will concatenated
+    this.dataChunks.push(chunk);
+};
+
+/**
+ * https://www.w3.org/TR/PNG/#11tRNS
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodeTRNS = function (chunk) {
+    this.png.transparency_lookup = chunk;
+};
+
+/**
+ * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IEND
+ */
+PNGReader.prototype.decodeIEND = function () {
+};
+
+/**
  * Uncompress IDAT chunks
  * @returns {Promise<void>}
- */
+ */
 PNGReader.prototype.decodePixels = async function () {
-    const png = this.png;
-
-    // leniently: a corrupt adler32 trailer over a sound deflate payload is common enough in the
-    // wild that Chrome and libpng both accept it, and a texture that refuses to load is worse than
-    // one whose checksum nobody reads
+    const png = this.png;
+
+    // leniently: a corrupt adler32 trailer over a sound deflate payload is common enough in the
+    // wild that Chrome and libpng both accept it, and a texture that refuses to load is worse than
+    // one whose checksum nobody reads
     const decompressed_data = await png_inflate(this.dataChunks, true);
-
-    // https://www.w3.org/TR/png-3/#8InterlaceMethods
-    if (png.getInterlaceMethod() === 0) {
-        this.png.pixels = this.interlaceNone(decompressed_data);
-    } 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
-
-/**
- * Reconstruct a non-interlaced image.
- *
- * Filtering is byte-wise, so at bit depths below eight the reconstructed scanline is still packed
- * and has to be unpacked into the output separately. At eight bits and above the two are the same
- * thing, and the reconstruction is written straight into the output with no intermediate row.
- *
- * @param {Uint8Array} data
- * @returns {Uint8Array}
- */
-PNGReader.prototype.interlaceNone = function (data) {
-
-    const png = this.png;
-
-    const depth = png.bitDepth;
-    const channels = png.colors;
-
-    const width = png.width;
-    const height = png.height;
-
-    // the specification's `bpp`: whole bytes per pixel, and never less than one
-    const bytes_per_pixel = Math.max(1, Math.ceil(channels * depth / 8));
-
-    const bytes_per_row = Math.ceil(channels * depth * width / 8);
-
-    if (depth < 8) {
-        return interlace_none_packed(data, depth, channels * width, bytes_per_pixel, bytes_per_row, height);
-    }
-
-    const pixels = new Uint8Array(bytes_per_row * height);
-
-    let offset = 0;
-
-    const data_length = data.length;
-
-    for (let i = 0; i < data_length; i += bytes_per_row + 1) {
-
-        const scanline_address = i + 1;
-
-        const filter_type = data[i];
-
-        png_unfilter(
-            filter_type,
-            data,
-            scanline_address,
-            pixels,
-            bytes_per_pixel,
-            offset,
-            offset - bytes_per_row,
-            bytes_per_row
-        );
-
-        offset += bytes_per_row;
-
-    }
-
-    return pixels;
-
-};
-
-/**
- * The sub-byte half of {@link PNGReader#interlaceNone}.
- *
- * Two packed rows are kept, alternating, because the `Up`, `Average` and `Paeth` filters predict
- * from the previous scanline as it was *packed*, not as it was unpacked.
- *
- * @param {Uint8Array} data
- * @param {number} depth `1`, `2` or `4`
- * @param {number} samples_per_row
- * @param {number} bytes_per_pixel
- * @param {number} bytes_per_row packed
- * @param {number} height
- * @returns {Uint8Array} one byte per sample
- */
-function interlace_none_packed(data, depth, samples_per_row, bytes_per_pixel, bytes_per_row, height) {
-    const pixels = new Uint8Array(samples_per_row * height);
-
-    const rows = new Uint8Array(bytes_per_row * 2);
-
-    const rows_available = Math.floor(data.length / (bytes_per_row + 1));
-    const row_count = height < rows_available ? height : rows_available;
-
-    let at = 0;
-    let previous_row_offset = -1;
-
-    for (let y = 0; y < row_count; y++) {
-        const filter_type = data[at++];
-
-        const row_offset = (y & 1) * bytes_per_row;
-
-        png_unfilter(
-            filter_type,
-            data,
-            at,
-            rows,
-            bytes_per_pixel,
-            row_offset,
-            previous_row_offset,
-            bytes_per_row
-        );
-
-        at += bytes_per_row;
-
-        png_unpack_samples(rows, row_offset, depth, samples_per_row, pixels, y * samples_per_row);
-
-        previous_row_offset = row_offset;
-    }
-
-    return pixels;
-}
-
-
-/**
- * De-interlace an image according to the Adam7 scheme.
- *
- * Each of the seven passes is its own little image with its own scanline width, so its own
- * filtering and — below eight bits — its own packing. Reconstructed rows land in a two-row scratch
- * (the filters predict from the previous row of the same pass) and are scattered into the output.
- *
- * @param {Uint8Array} data
- * @returns {Uint8Array}
- */
-PNGReader.prototype.interlaceAdam7 = function (data) {
-
-    const png = this.png;
-
-    const depth = png.bitDepth;
-    const channels = png.colors;
-
-    const width = png.width;
-    const height = png.height;
-
-    const packed = depth < 8;
-
-    // the specification's `bpp`, used for filtering
-    const bytes_per_pixel = Math.max(1, Math.ceil(channels * depth / 8));
-
-    // bytes a pixel occupies in the *output*, where sub-byte samples have been expanded
-    const output_pixel_bytes = channels * (depth === 16 ? 2 : 1);
-
-    const pixels = new Uint8Array(output_pixel_bytes * width * 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
-    ];
-
-    let offset = 0;
-
-    // two reconstructed rows, alternating, so that the previous one is still there to predict from
-    const line_bytes_buffer = new Uint8Array(Math.ceil(channels * depth * width / 8) * 2);
-
-    // one unpacked row, used only below eight bits
-    const sample_buffer = packed ? new Uint8Array(channels * width) : null;
-
-    // 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 pass_samples = channels * pass_width;
-        const pass_line_bytes = Math.ceil(pass_samples * depth / 8);
-
-        // 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) * pass_line_bytes;
-
-            png_unfilter(
-                filter_type,
-                data,
-                offset,
-                line_bytes_buffer,
-                bytes_per_pixel,
-                line_offset,
-                previous_line_offset,
-                pass_line_bytes
-            );
-
-            offset += pass_line_bytes;
-            previous_line_offset = line_offset;
-
-            // below eight bits the reconstruction is still packed, so expand it before scattering
-            let source = line_bytes_buffer;
-            let source_offset = line_offset;
-
-            if (packed) {
-                png_unpack_samples(line_bytes_buffer, line_offset, depth, pass_samples, sample_buffer, 0);
-
-                source = sample_buffer;
-                source_offset = 0;
-            }
-
-            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 < output_pixel_bytes; i++) {
-                    const out_offset = (outputY * width + outputX) * output_pixel_bytes + i;
-
-                    pixels[out_offset] = source[source_offset + x * output_pixel_bytes + i];
-                }
-            }
-        }
-    }
-
-    return pixels;
-};
-
-// Unfiltering
-
-/**
- * Reconstruct one filtered scanline. Kept as a method so the reader's surface is unchanged; the
- * dispatch itself lives in {@link png_unfilter}.
- *
- * @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
- *
- * @see https://www.w3.org/TR/PNG-Filters.html
- */
-PNGReader.prototype.unFilter = function (
-    filter_type,
-    data,
-    scanline_address,
-    output,
-    bytes_per_pixel,
-    output_offset,
-    output_offset_previous,
-    length
-) {
-    png_unfilter(
-        filter_type,
-        data,
-        scanline_address,
-        output,
-        bytes_per_pixel,
-        output_offset,
-        output_offset_previous,
-        length
-    );
-}
-
-/**
+
+    // https://www.w3.org/TR/png-3/#8InterlaceMethods
+    if (png.getInterlaceMethod() === 0) {
+        this.png.pixels = this.interlaceNone(decompressed_data);
+    } 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
+
+/**
+ * Reconstruct a non-interlaced image.
+ *
+ * Filtering is byte-wise, so at bit depths below eight the reconstructed scanline is still packed
+ * and has to be unpacked into the output separately. At eight bits and above the two are the same
+ * thing, and the reconstruction is written straight into the output with no intermediate row.
+ *
+ * @param {Uint8Array} data
+ * @returns {Uint8Array}
+ */
+PNGReader.prototype.interlaceNone = function (data) {
+
+    const png = this.png;
+
+    const depth = png.bitDepth;
+    const channels = png.colors;
+
+    const width = png.width;
+    const height = png.height;
+
+    // the specification's `bpp`: whole bytes per pixel, and never less than one
+    const bytes_per_pixel = Math.max(1, Math.ceil(channels * depth / 8));
+
+    const bytes_per_row = Math.ceil(channels * depth * width / 8);
+
+    if (depth < 8) {
+        return interlace_none_packed(data, depth, channels * width, bytes_per_pixel, bytes_per_row, height);
+    }
+
+    const pixels = new Uint8Array(bytes_per_row * height);
+
+    let offset = 0;
+
+    const data_length = data.length;
+
+    for (let i = 0; i < data_length; i += bytes_per_row + 1) {
+
+        const scanline_address = i + 1;
+
+        const filter_type = data[i];
+
+        png_unfilter(
+            filter_type,
+            data,
+            scanline_address,
+            pixels,
+            bytes_per_pixel,
+            offset,
+            offset - bytes_per_row,
+            bytes_per_row
+        );
+
+        offset += bytes_per_row;
+
+    }
+
+    return pixels;
+
+};
+
+/**
+ * The sub-byte half of {@link PNGReader#interlaceNone}.
+ *
+ * Two packed rows are kept, alternating, because the `Up`, `Average` and `Paeth` filters predict
+ * from the previous scanline as it was *packed*, not as it was unpacked.
+ *
+ * @param {Uint8Array} data
+ * @param {number} depth `1`, `2` or `4`
+ * @param {number} samples_per_row
+ * @param {number} bytes_per_pixel
+ * @param {number} bytes_per_row packed
+ * @param {number} height
+ * @returns {Uint8Array} one byte per sample
+ */
+function interlace_none_packed(data, depth, samples_per_row, bytes_per_pixel, bytes_per_row, height) {
+    const pixels = new Uint8Array(samples_per_row * height);
+
+    const rows = new Uint8Array(bytes_per_row * 2);
+
+    const rows_available = Math.floor(data.length / (bytes_per_row + 1));
+    const row_count = height < rows_available ? height : rows_available;
+
+    let at = 0;
+    let previous_row_offset = -1;
+
+    for (let y = 0; y < row_count; y++) {
+        const filter_type = data[at++];
+
+        const row_offset = (y & 1) * bytes_per_row;
+
+        png_unfilter(
+            filter_type,
+            data,
+            at,
+            rows,
+            bytes_per_pixel,
+            row_offset,
+            previous_row_offset,
+            bytes_per_row
+        );
+
+        at += bytes_per_row;
+
+        png_unpack_samples(rows, row_offset, depth, samples_per_row, pixels, y * samples_per_row);
+
+        previous_row_offset = row_offset;
+    }
+
+    return pixels;
+}
+
+
+/**
+ * De-interlace an image according to the Adam7 scheme.
+ *
+ * Each of the seven passes is its own little image with its own scanline width, so its own
+ * filtering and — below eight bits — its own packing. Reconstructed rows land in a two-row scratch
+ * (the filters predict from the previous row of the same pass) and are scattered into the output.
+ *
+ * @param {Uint8Array} data
+ * @returns {Uint8Array}
+ */
+PNGReader.prototype.interlaceAdam7 = function (data) {
+
+    const png = this.png;
+
+    const depth = png.bitDepth;
+    const channels = png.colors;
+
+    const width = png.width;
+    const height = png.height;
+
+    const packed = depth < 8;
+
+    // the specification's `bpp`, used for filtering
+    const bytes_per_pixel = Math.max(1, Math.ceil(channels * depth / 8));
+
+    // bytes a pixel occupies in the *output*, where sub-byte samples have been expanded
+    const output_pixel_bytes = channels * (depth === 16 ? 2 : 1);
+
+    const pixels = new Uint8Array(output_pixel_bytes * width * 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
+    ];
+
+    let offset = 0;
+
+    // two reconstructed rows, alternating, so that the previous one is still there to predict from
+    const line_bytes_buffer = new Uint8Array(Math.ceil(channels * depth * width / 8) * 2);
+
+    // one unpacked row, used only below eight bits
+    const sample_buffer = packed ? new Uint8Array(channels * width) : null;
+
+    // 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 pass_samples = channels * pass_width;
+        const pass_line_bytes = Math.ceil(pass_samples * depth / 8);
+
+        // 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) * pass_line_bytes;
+
+            png_unfilter(
+                filter_type,
+                data,
+                offset,
+                line_bytes_buffer,
+                bytes_per_pixel,
+                line_offset,
+                previous_line_offset,
+                pass_line_bytes
+            );
+
+            offset += pass_line_bytes;
+            previous_line_offset = line_offset;
+
+            // below eight bits the reconstruction is still packed, so expand it before scattering
+            let source = line_bytes_buffer;
+            let source_offset = line_offset;
+
+            if (packed) {
+                png_unpack_samples(line_bytes_buffer, line_offset, depth, pass_samples, sample_buffer, 0);
+
+                source = sample_buffer;
+                source_offset = 0;
+            }
+
+            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 < output_pixel_bytes; i++) {
+                    const out_offset = (outputY * width + outputX) * output_pixel_bytes + i;
+
+                    pixels[out_offset] = source[source_offset + x * output_pixel_bytes + i];
+                }
+            }
+        }
+    }
+
+    return pixels;
+};
+
+// Unfiltering
+
+/**
+ * Reconstruct one filtered scanline. Kept as a method so the reader's surface is unchanged; the
+ * dispatch itself lives in {@link png_unfilter}.
+ *
+ * @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
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+PNGReader.prototype.unFilter = function (
+    filter_type,
+    data,
+    scanline_address,
+    output,
+    bytes_per_pixel,
+    output_offset,
+    output_offset_previous,
+    length
+) {
+    png_unfilter(
+        filter_type,
+        data,
+        scanline_address,
+        output,
+        bytes_per_pixel,
+        output_offset,
+        output_offset_previous,
+        length
+    );
+}
+
+/**
  * Parse the PNG file. Keep this reader and its input buffer unchanged until the promise settles.
  * @returns {Promise<PNG>}
- */
+ */
 PNGReader.prototype.parse = async function () {
-
-    this.decodeHeader();
-
-    for (; ;) {
-
+
+    this.decodeHeader();
+
+    for (; ;) {
+
         const type = await this.decodeChunk();
-
-        if (type === 'IEND') {
-            // reached the end
-            break;
-        }
-
-    }
-
+
+        if (type === 'IEND') {
+            // reached the end
+            break;
+        }
+
+    }
+
     await this.decodePixels();
-
-    return this.png;
-
-};
+
+    return this.png;
+
+};