Skip to content

Make videos on the computer you already own. FreeVideo runs MiniMax H3 in as little as 8 GB of VRAM and 16 GB of RAM, and adapts its acceleration path to your hardware.

13.8 KB
Raw Blame
import {createEncoder, renderError} from './whitebox_encode.js';

const THREE_URL = new URL('./vendor/three/three.module.min.js', import.meta.url);
// Total budget grows with the frame count and stays under the server's 150 s lease.
const deadlineMs = frames => Math.min(140000, 10000 + 400 * frames);
let threeSource;
function loadThree() {
    if (!threeSource) threeSource = fetch(THREE_URL).then(response => {
        if (!response.ok) throw new Error(`Bundled Three.js: HTTP ${response.status}`);
        return response.text();
    }).catch(error => { threeSource = null; throw error; });
    return threeSource;
}

// Stringified into a blob Worker owned by the opaque-origin iframe. Untrusted
// code never executes on either Window thread, so even top-level while(true)
// can be stopped by destroying the iframe and its descendant Worker.
function sceneWorker() {
    self.onmessage = async event => {
        self.onmessage = null;
        const {threeCode, sceneCode, width, height} = event.data;
        const port = event.ports[0];
        const send = port.postMessage.bind(port);
        const message = error => String(error?.message ?? error).split(/\r?\n/)[0];
        const report = error => send({type: 'error', message: message(error)});
        self.addEventListener('error', event => { event.preventDefault(); report(event.error || event.message); });
        self.addEventListener('unhandledrejection', event => { event.preventDefault(); report(event.reason); });
        const urls = [];
        let renderer;
        try {
            const moduleURL = code => {
                const url = URL.createObjectURL(new Blob([code], {type: 'text/javascript'}));
                urls.push(url);
                return url;
            };
            const THREE = await import(moduleURL(threeCode));
            // Capture host operations before importing the Agent's module.
            const clamp = Math.min;
            const canvas = new OffscreenCanvas(width, height);
            // Whitebox reference frames use full output resolution; avoiding
            // multisample antialiasing keeps software GL within the deadline.
            renderer = new THREE.WebGLRenderer({canvas, preserveDrawingBuffer: true});
            renderer.setSize(width, height, false);
            renderer.shadowMap.enabled = true;
            renderer.shadowMap.type = THREE.PCFSoftShadowMap;
            const render = renderer.render.bind(renderer);
            const snapshot = canvas.transferToImageBitmap.bind(canvas);
            const module = await import(moduleURL(sceneCode));
            if (typeof module.build !== 'function') throw new Error('Scene must export build(THREE)');
            const state = await module.build(THREE);
            if (!state?.scene?.isScene || !state?.camera?.isCamera || typeof state.update !== 'function')
                throw new Error('build(THREE) must return {scene, camera, update(t)}');
            // Reference-video output is 960x544. Bound scene-requested shadow
            // textures to 1024px to keep software GL and untrusted allocations
            // practical; PCFSoft shadows and the scene's lighting stay enabled.
            state.scene.traverse(object => {
                if (object.shadow?.mapSize) {
                    object.shadow.mapSize.x = clamp(object.shadow.mapSize.x, 1024);
                    object.shadow.mapSize.y = clamp(object.shadow.mapSize.y, 1024);
                }
            });
            if (state.camera.isPerspectiveCamera) {
                state.camera.aspect = width / height;
                state.camera.updateProjectionMatrix();
            }
            port.onmessage = async event => {
                const {type, index, fps} = event.data;
                if (type !== 'frame') return;
                try {
                    await state.update(Math.min(index / fps, 5.0));
                    render(state.scene, state.camera);
                    if (renderer.getContext().isContextLost()) throw new Error('WebGL context lost');
                    const bitmap = snapshot();
                    send({type: 'frame', index, bitmap}, [bitmap]);
                } catch (error) { report(error); }
            };
            port.start();
            send({type: 'ready'});
        } catch (error) { report(error); }
        finally { urls.forEach(url => URL.revokeObjectURL(url)); }
    };
}

function sandboxWindow() {
    addEventListener('message', function initialize(event) {
        if (event.source !== parent || !event.ports[0]) return;
        removeEventListener('message', initialize);
        const port = event.ports[0];
        let worker, workerURL, bridge;
        const stop = () => {
            worker?.terminate();
            bridge?.port1.close();
            if (workerURL) URL.revokeObjectURL(workerURL);
        };
        port.onmessage = event => {
            if (event.data.type === 'cancel') {
                stop();
                port.postMessage({type: 'stopped'});
            } else bridge?.port1.postMessage(event.data);
        };
        port.start();
        try {
            workerURL = URL.createObjectURL(new Blob([event.data.workerCode], {type: 'text/javascript'}));
            worker = new Worker(workerURL);
            bridge = new MessageChannel();
            bridge.port1.onmessage = event => {
                if (!['ready', 'frame', 'error'].includes(event.data?.type)) {
                    event.data?.bitmap?.close();
                    return;
                }
                const {bitmap} = event.data;
                port.postMessage(event.data, bitmap ? [bitmap] : []);
            };
            worker.onerror = event => { event.preventDefault(); port.postMessage({type: 'error', message: event.message}); };
            worker.postMessage(event.data, [bridge.port2]);
        } catch (error) { stop(); port.postMessage({type: 'error', message: error.message}); }
    });
}

function sandboxDocument() {
    // No same-origin permission, network, nested frames, forms or external
    // scripts. Blob Workers inherit this policy, including connect-src 'none'.
    const policy = "default-src 'none'; script-src 'unsafe-inline' blob:; worker-src blob:; "
        + "connect-src 'none'; img-src blob: data:; media-src 'none'; frame-src 'none'; "
        + "object-src 'none'; base-uri 'none'; form-action 'none'";
    return `<!doctype html><meta http-equiv="Content-Security-Policy" content="${policy}">`
        + `<script>(${sandboxWindow.toString()})();<\/script>`;
}

/**
 * Render an untrusted Three.js ES module entirely in the current browser.
 * onProgress receives {frames, total, progress}; signal cancels with AbortError.
 * Errors expose code: scene_error | scene_timeout | encode_unsupported.
 * Rendering and encoding have a total deadline of 10 s plus 0.4 s per frame (at most 140 s).
 * Only compressed video samples and the first PNG are retained.
 */
export async function renderWhitebox(sceneCode, {
    width = 960, height = 544, frames = 124, fps = 24, onProgress, signal,
} = {}) {
    if (signal?.aborted) throw new DOMException('Whitebox render aborted', 'AbortError');
    if (typeof sceneCode !== 'string' || !sceneCode.trim()) throw renderError('scene_error', 'Empty scene module');
    if (![width, height].every(n => Number.isInteger(n) && n > 0 && n <= 4096)
        || width * height > 4096 * 2160 || !Number.isInteger(frames) || frames < 1 || frames > 3600
        || !Number.isFinite(fps) || fps <= 0 || fps > 120)
        throw renderError('scene_error', 'Invalid width, height, frames or fps');
    if (typeof Worker !== 'function' || typeof OffscreenCanvas !== 'function')
        throw renderError('scene_error', 'This browser requires Worker and OffscreenCanvas WebGL support');
    const iframe = document.createElement('iframe');
    iframe.setAttribute('sandbox', 'allow-scripts');
    iframe.setAttribute('aria-hidden', 'true');
    iframe.hidden = true;
    iframe.srcdoc = sandboxDocument();
    const channel = new MessageChannel();
    const port = channel.port1;
    const canvas = document.createElement('canvas');
    canvas.width = width; canvas.height = height;
    const context = canvas.getContext('2d', {willReadFrequently: true, alpha: false});
    let encoder, firstFrame, pending, stopped, initialized = false, settled = false;
    const bitmaps = new Set();
    let fail;
    const failed = new Promise((resolve, reject) => { fail = reject; });
    const reject = error => {
        if (settled) return;
        fail(error);
        pending?.reject(error);
        pending = null;
    };
    const deadline = deadlineMs(frames);
    const timer = setTimeout(() => reject(renderError('scene_timeout', `Scene exceeded the ${Math.round(deadline / 1000)} s rendering deadline`)), deadline);
    const abort = () => reject(new DOMException('Whitebox render aborted', 'AbortError'));
    signal?.addEventListener('abort', abort, {once: true});
    const receive = () => {
        const response = new Promise((resolve, reject) => { pending = {resolve, reject}; });
        response.catch(() => {}); // A prefetched frame can fail while encoding the preceding one.
        return response;
    };
    port.onmessage = event => {
        const data = event.data;
        if (data.type === 'stopped') { stopped?.(); return; }
        if (settled) { data.bitmap?.close(); return; }
        if (data.type === 'error') { reject(renderError('scene_error', data.message)); return; }
        if (pending) {
            if (data.bitmap) bitmaps.add(data.bitmap);
            const next = pending; pending = null; next.resolve(data);
        }
        else data.bitmap?.close();
    };
    port.start();
    try {
        return await Promise.race([failed, (async () => {
            const threeCode = await loadThree();
            if (settled) return;
            const ready = receive();
            iframe.onload = () => {
                try {
                    if (settled) return;
                    iframe.contentWindow.postMessage({threeCode, sceneCode, width, height,
                        workerCode: `(${sceneWorker.toString()})();`}, '*', [channel.port2]);
                    initialized = true;
                } catch (error) { reject(renderError('scene_error', error)); }
            };
            document.body.appendChild(iframe);
            const started = await ready;
            if (started.type !== 'ready') throw renderError('scene_error', 'Invalid sandbox startup response');
            let nonBlack = false;
            const requestFrame = index => {
                const response = receive();
                port.postMessage({type: 'frame', index, fps});
                return response;
            };
            let nextFrame = requestFrame(0);
            for (let index = 0; index < frames; index++) {
                if (settled) return;
                const data = await nextFrame;
                if (settled) return;
                if (data.type !== 'frame' || data.index !== index || !data.bitmap)
                    throw renderError('scene_error', 'Invalid sandbox frame response');
                // Render the next picture while capturing/encoding this one.
                // At most two bitmaps are alive; the Worker never runs ahead.
                if (index + 1 < frames) nextFrame = requestFrame(index + 1);
                const draw = () => {
                    context.drawImage(data.bitmap, 0, 0);
                    if (!nonBlack) {
                        const pixels = context.getImageData(0, 0, width, height).data;
                        for (let p = 0; p < pixels.length; p += 4) {
                            if (pixels[p] > 3 || pixels[p + 1] > 3 || pixels[p + 2] > 3) { nonBlack = true; break; }
                        }
                    }
                };
                try {
                    if (index === 0) {
                        draw();
                        firstFrame = await new Promise(resolve => canvas.toBlob(resolve, 'image/png'));
                        if (!firstFrame) throw renderError('scene_error', 'First-frame PNG capture failed');
                        if (settled) return;
                        encoder = await createEncoder(canvas, {width, height, fps, frames});
                        if (settled) { encoder.cancel(); return; }
                    }
                    try { await encoder.add(index, fps, draw); }
                    catch (error) { throw error.code ? error : renderError('encode_unsupported', error); }
                } finally { data.bitmap.close(); bitmaps.delete(data.bitmap); }
                if (settled) return;
                onProgress?.({frames: index + 1, total: frames, progress: (index + 1) / frames});
            }
            if (!nonBlack) throw renderError('scene_error', 'All rendered frames are black');
            try { return {...await encoder.finish(), frames, firstFrame}; }
            catch (error) { throw error.code ? error : renderError('encode_unsupported', error); }
        })()]);
    } catch (error) {
        throw error.code || error.name === 'AbortError' ? error : renderError('scene_error', error);
    } finally {
        settled = true;
        clearTimeout(timer);
        signal?.removeEventListener('abort', abort);
        try { encoder?.cancel(); } catch { /* Continue releasing the sandbox. */ }
        iframe.onload = null;
        if (initialized && iframe.isConnected) {
            // A detached Document may leave a running DedicatedWorker alive.
            // Keep its trusted Window active until it has called terminate().
            await new Promise(resolve => {
                const guard = setTimeout(resolve, 1000);
                stopped = () => { clearTimeout(guard); resolve(); };
                port.postMessage({type: 'cancel'});
            });
        }
        port.close(); channel.port2.close();
        iframe.remove();
        bitmaps.forEach(bitmap => bitmap.close()); bitmaps.clear();
        canvas.width = canvas.height = 0;
    }
}