tav-media/lib/src/wasm/tav-bitmap-executor.js

Cross platform media editing framework

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { Http } from '../io/http';
import { tav } from '../tav';
export class TAVBitmapExecutor {
    static preload(path) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.images[path]) {
                return Promise.resolve(this.images[path]);
            }
            const url = Http.getUrl(path);
            if (!this.sharedCanvas) {
                this.sharedCanvas = document.createElement('canvas');
                this.sharedCanvas.width = 4096;
                this.sharedCanvas.height = 4096;
            }
            const imageEl = new Image();
            imageEl.src = url;
            imageEl.crossOrigin = 'anonymous';
            this.images[path] = imageEl;
            return new Promise((res) => {
                imageEl.onload = _e => res(imageEl);
                imageEl.onerror = (e) => {
                    console.error(e);
                    res(null);
                };
            });
        });
    }
    static execute(path) {
        const imageEl = TAVBitmapExecutor.images[path];
        if (!imageEl) {
            console.error('Please call preload(path) before using TAVBitmapExecutor');
            throw new Error(`${path} not preloaded.`);
        }
        let { width, height } = imageEl;
        width = Math.min(width, this.sharedCanvas.width);
        height = Math.min(height, this.sharedCanvas.height);
        const context2D = TAVBitmapExecutor.sharedCanvas.getContext('2d');
        context2D.clearRect(0, 0, width, height);
        context2D.drawImage(imageEl, 0, 0, width, height);
        const imageData = context2D.getImageData(0, 0, width, height);
        const dataUint8Array = imageData.data;
        const module = tav;
        const numBytes = dataUint8Array.byteLength * dataUint8Array.BYTES_PER_ELEMENT;
        const dataPtr = module._malloc(numBytes);
        TAVBitmapExecutor.lastSampleData[path] = dataPtr;
        const dataOnHeap = new Uint8ClampedArray(module.HEAPU8.buffer, dataPtr, numBytes);
        dataOnHeap.set(dataUint8Array);
        return {
            bytes: dataOnHeap.byteOffset,
            length: dataOnHeap.length,
            width,
            height,
        };
    }
    static freeBuffer(path) {
        if (!TAVBitmapExecutor.lastSampleData[path]) {
            return;
        }
        const module = tav;
        module._free(TAVBitmapExecutor.lastSampleData[path]);
        TAVBitmapExecutor.lastSampleData[path] = null;
    }
}
TAVBitmapExecutor.images = {};
TAVBitmapExecutor.lastSampleData = {};