@woosh/meep-engine 3.14.2 → 3.14.3

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

@@ -1,656 +0,0 @@
-/*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
- *
- * @returns {string} chunk type
- */
-PNGReader.prototype.decodeChunk = 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':
-            png_chunk_decode_zTXt(chunk);
-            break;
-        case 'iTXt':
-            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 () {
-};
-
-/**
- * Uncompress IDAT chunks
- */
-PNGReader.prototype.decodePixels = 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 decompressed_data = 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
-    );
-}
-
-/**
- * Parse the PNG file
- * @returns {PNG}
- */
-PNGReader.prototype.parse = function () {
-
-    this.decodeHeader();
-
-    for (; ;) {
-
-        const type = this.decodeChunk();
-
-        if (type === 'IEND') {
-            // reached the end
-            break;
-        }
-
-    }
-
-    this.decodePixels();
-
-    return this.png;
-
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"PNG_HEADER_BYTES.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNG_HEADER_BYTES.js"],"names":[],"mappings":"AAAA,wCAAiF"}

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

@@ -1 +0,0 @@
-{"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

@@ -1,53 +0,0 @@
-import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
-import { png_inflate } from "../png_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 = png_inflate([new Uint8Array(buffer.data, buffer.position, remaining_bytes)]);
-
-        buffer.fromArrayBuffer(decoded.buffer);
-
-        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.map

@@ -1 +0,0 @@
-{"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"}