@awayjs/stage/dist/lib/parsers/Image2DParser.js

Stage for AwayJS

import { __extends } from "tslib";
import { URLLoaderDataFormat, ParserBase, ByteArray, URLRequest } from '@awayjs/core';
import { ExternalImage2D } from '../image/ExternalImage2D';
import { ImageUtils } from '../utils/ImageUtils';
import { DefaultStageFactory } from '../factories/DefaultStageFactory';
import { Settings } from '../Settings';
function getImageFromData(blob, callback) {
    // self is window for main ui or self for worker, need use it
    var supportImageBitmap = Settings.ENABLE_PARSER_NATIVE_BITMAP && ('createImageBitmap' in self);
    if (supportImageBitmap) {
        self.createImageBitmap(blob).then(callback);
        return null;
    }
    var url = URL.createObjectURL(blob);
    var image = new Image();
    image.src = url;
    if (!image.naturalWidth) {
        image.onload = function (event) {
            callback(image);
            URL.revokeObjectURL(url);
        };
        return null;
    }
    return image;
}
var Image2DParser = /** @class */ (function (_super) {
    __extends(Image2DParser, _super);
    /**
     * Creates a new Image2DParser object.
     * @param uri The url or id of the data or file to be parsed.
     * @param extra The holder for extra contextual data that the parser might need.
     */
    function Image2DParser(factory, alphaChannel) {
        if (factory === void 0) { factory = null; }
        if (alphaChannel === void 0) { alphaChannel = null; }
        var _this = _super.call(this, URLLoaderDataFormat.BLOB) || this;
        _this._factory = factory || new DefaultStageFactory();
        _this._alphaChannel = alphaChannel;
        return _this;
    }
    /**
     * Indicates whether or not a given file extension is supported by the parser.
     * @param extension The file extension of a potential file to be parsed.
     * @return Whether or not the given file type is supported.
     */
    Image2DParser.supportsType = function (extension) {
        extension = extension.toLowerCase().trim();
        return this.SUPPORTED_TYPES.includes(extension);
    };
    /**
     * Tests whether a data block can be parsed by the parser.
     * @param data The data block to potentially be parsed.
     * @return Whether or not the given data is supported.
     */
    Image2DParser.supportsData = function (data) {
        if (data instanceof HTMLImageElement)
            return true;
        if (!(data instanceof ByteArray))
            return false;
        var ba = data;
        ba.position = 0;
        if (ba.readUnsignedShort() == 0xd8ff)
            return true; // JPEG, maybe check for "JFIF" as well?
        ba.position = 0;
        if (ba.readShort() == 0x424D)
            return true; // BMP
        ba.position = 1;
        if (ba.readUTFBytes(3) == 'PNG')
            return true;
        ba.position = 0;
        if (ba.readUTFBytes(3) == 'GIF' && ba.readShort() == 0x3839 && ba.readByte() == 0x61)
            return true;
        ba.position = 0;
        if (ba.readUTFBytes(3) == 'ATF')
            return true;
        return false;
    };
    Image2DParser.prototype.finalizeAsset = function (asset, fileName) {
        if (this._alphaChannel)
            asset.alphaChannel = this._alphaChannel;
        _super.prototype.finalizeAsset.call(this, asset, fileName);
    };
    /**
     * @inheritDoc
     */
    Image2DParser.prototype.proceedParsing = function () {
        var _this = this;
        var asset;
        if (this.data instanceof HTMLImageElement) {
            //data is already an image
            this._finalizeAssetFromImage(this.data);
        }
        else if (this.data instanceof URLRequest) {
            //data is an external image
            asset = new ExternalImage2D(this.data);
            this.finalizeAsset(asset, this.fileName);
            this._content = asset;
        }
        else {
            //check if data can be resolved to a blob
            var blob = void 0;
            if (this.data instanceof ByteArray) { // Parse a ByteArray
                var ba = this.data;
                ba.position = 0;
                blob = new Blob([this.data.arraybytes]);
            }
            else if (this.data instanceof ArrayBuffer) { // Parse an ArrayBuffer
                blob = new Blob([this.data]);
            }
            else if (this.data instanceof Blob) {
                blob = this.data;
            }
            else {
                throw 'Unknow data';
            }
            var image = getImageFromData(blob, function (image) {
                _this._finalizeAssetFromImage(image);
                //notify parser of async parsing completion
                _this.finishParsing();
            });
            if (image)
                this._finalizeAssetFromImage(image);
        }
        //notify parser of sync parsing completion
        if (this._content)
            this.finishParsing();
    };
    Image2DParser.prototype._finalizeAssetFromImage = function (image) {
        var asset = ImageUtils.imageToBitmapImage2D(image, this._factory, false);
        this.finalizeAsset(asset, this.fileName);
        this._content = asset;
    };
    Image2DParser.SUPPORTED_TYPES = ['jpg', 'jpeg', 'png', 'gif'];
    return Image2DParser;
}(ParserBase));
export { Image2DParser };