@aelionsdk/sdk 0.1.0-beta.1

package/dist/player.js

@@ -0,0 +1,522 @@
+import { AudioDrivenVideoScheduler, AudioWorkletClock, TransferableAudioWorkletClock, renderIrAudio, } from '@aelionsdk/audio';
+import { sampleIndexAtTime } from '@aelionsdk/core';
+import { normalizePreviewQuality } from './preview-quality.js';
+function runtimeErrorCode(error) {
+    if (error !== null && typeof error === 'object') {
+        const diagnostics = Reflect.get(error, 'diagnostics');
+        if (Array.isArray(diagnostics)) {
+            const first = diagnostics[0];
+            const code = first !== null && typeof first === 'object' ? Reflect.get(first, 'code') : undefined;
+            if (typeof code === 'string')
+                return code;
+        }
+        const code = Reflect.get(error, 'code');
+        if (typeof code === 'string')
+            return code;
+    }
+    return 'PLAYER_RUNTIME_FAILED';
+}
+export class AelionPlayer {
+    #session;
+    #onRuntimeError;
+    #runtimeAssets;
+    #listeners = new Set();
+    #state = 'idle';
+    #clock;
+    #scheduler;
+    #fillHandle;
+    #nextAudioFrame = 0;
+    #fillTask;
+    #fillGeneration = -1;
+    #runtimeInitTask;
+    #runtimeDisposeTask;
+    #disposeTask;
+    #fillController = new AbortController();
+    #videoController = new AbortController();
+    #generation = 0;
+    #lastTimeUs = 0;
+    #renderedFrames = 0;
+    #droppedFrames = 0;
+    #errors = 0;
+    #lastErrorCode;
+    #previewQuality = normalizePreviewQuality();
+    #lastDisposedRuntime = null;
+    constructor(session, onRuntimeError, runtimeAssets) {
+        this.#session = session;
+        this.#onRuntimeError = onRuntimeError;
+        this.#runtimeAssets = runtimeAssets;
+    }
+    get state() {
+        return this.#state;
+    }
+    get currentTimeUs() {
+        if (this.#state === 'ended' || this.#state === 'error' || this.#state === 'disposed') {
+            return this.#lastTimeUs;
+        }
+        return this.#clock?.nowUs() ?? this.#lastTimeUs;
+    }
+    async play() {
+        try {
+            if (this.#state === 'disposed')
+                throw new ReferenceError('AelionPlayer is disposed');
+            const ir = this.#session.requireIr();
+            const generation = this.#generation;
+            await this.#ensureRuntime();
+            if (!this.#playContinuationCurrent(generation)) {
+                throw new DOMException('Player play became stale', 'AbortError');
+            }
+            await this.#requestAudioFill(true);
+            if (!this.#playContinuationCurrent(generation)) {
+                throw new DOMException('Player play became stale', 'AbortError');
+            }
+            if (this.#state === 'paused')
+                await this.#clock?.resume();
+            else
+                await this.#clock?.start();
+            if (!this.#playContinuationCurrent(generation)) {
+                throw new DOMException('Player play became stale', 'AbortError');
+            }
+            this.#state = 'playing';
+            this.#session.notifyStatsChanged();
+            this.#scheduler?.start();
+            this.#fillHandle ??= globalThis.setInterval(() => {
+                void this.#requestAudioFill(false);
+            }, 20);
+            if (this.currentTimeUs >= ir.durationUs)
+                await this.seek(0);
+        }
+        catch (error) {
+            this.#failRuntime(error);
+            throw error;
+        }
+    }
+    async pause() {
+        if (this.#state === 'disposed')
+            throw new ReferenceError('AelionPlayer is disposed');
+        const generation = this.#generation;
+        this.#scheduler?.pause();
+        if (this.#clock !== undefined)
+            await this.#clock.pause();
+        if (this.#disposeTask !== undefined || generation !== this.#generation)
+            return;
+        if (this.#state !== 'idle')
+            this.#state = 'paused';
+        this.#lastTimeUs = this.currentTimeUs;
+        this.#session.notifyStatsChanged();
+    }
+    async seek(timeUs) {
+        try {
+            const ir = this.#session.requireIr();
+            if (!Number.isSafeInteger(timeUs) || timeUs < 0 || timeUs >= ir.durationUs) {
+                throw new RangeError('Player seek target is outside the sequence duration');
+            }
+            await this.#ensureRuntime();
+            this.#advanceGeneration();
+            const generation = this.#generation;
+            const clock = this.#clock;
+            if (clock instanceof AudioWorkletClock)
+                clock.resetForSeek(timeUs);
+            else
+                clock?.seek(timeUs);
+            this.#nextAudioFrame = sampleIndexAtTime(timeUs, ir.sampleRate);
+            this.#lastTimeUs = timeUs;
+            await this.#requestAudioFill(true);
+            if (generation !== this.#generation)
+                return;
+            const signal = this.#videoController.signal;
+            if (signal.aborted)
+                return;
+            const result = await this.#session.preview.renderFrame({
+                timeUs,
+                signal,
+                ...this.#previewQuality,
+            });
+            if (generation !== this.#generation) {
+                result.bitmap.close();
+                return;
+            }
+            this.#publish({ generation, frameIndex: -1, timestampUs: timeUs, droppedFrames: 0 }, result);
+        }
+        catch (error) {
+            this.#failRuntime(error);
+            throw error;
+        }
+    }
+    scrub(timeUs) {
+        return this.#session.preview.renderFrame({ timeUs, ...this.#previewQuality });
+    }
+    setPreviewQuality(options) {
+        if (this.#state === 'disposed')
+            throw new ReferenceError('AelionPlayer is disposed');
+        this.#previewQuality = normalizePreviewQuality(options);
+        this.#advanceGeneration();
+        this.#session.notifyStatsChanged();
+    }
+    getStats() {
+        return Object.freeze({
+            state: this.#state,
+            currentTimeUs: this.currentTimeUs,
+            generation: this.#generation,
+            renderedFrames: this.#renderedFrames,
+            droppedFrames: this.#droppedFrames,
+            errors: this.#errors,
+            lastErrorCode: this.#lastErrorCode ?? null,
+            previewQuality: this.#previewQuality,
+            resources: this.#resourceStats(),
+        });
+    }
+    #resourceStats() {
+        const scheduler = this.#scheduler?.snapshot();
+        const clock = this.#clock;
+        const queue = clock instanceof AudioWorkletClock
+            ? clock.ring.snapshot()
+            : clock instanceof TransferableAudioWorkletClock
+                ? clock.snapshot()
+                : undefined;
+        return Object.freeze({
+            listeners: this.#listeners.size,
+            runtimeInitializing: this.#runtimeInitTask !== undefined,
+            audioFillScheduled: this.#fillHandle !== undefined,
+            audioFillInFlight: this.#fillTask !== undefined,
+            scheduler: Object.freeze({
+                present: scheduler !== undefined,
+                disposed: scheduler?.disposed ?? true,
+                scheduled: scheduler?.scheduled ?? false,
+                rendering: scheduler?.rendering ?? false,
+            }),
+            audio: Object.freeze({
+                mode: clock instanceof AudioWorkletClock
+                    ? 'shared-ring'
+                    : clock instanceof TransferableAudioWorkletClock
+                        ? 'transferable-queue'
+                        : 'none',
+                disposed: clock?.disposed ?? true,
+                contextState: clock?.context.state ?? null,
+                bufferedFrames: queue === undefined
+                    ? 0
+                    : 'availableReadFrames' in queue
+                        ? queue.availableReadFrames
+                        : queue.queuedFrames,
+                closed: queue === undefined ? true : 'state' in queue ? queue.state === 'closed' : queue.closed,
+            }),
+            lastDisposedRuntime: this.#lastDisposedRuntime,
+        });
+    }
+    subscribe(listener) {
+        if (this.#state === 'disposed')
+            throw new ReferenceError('AelionPlayer is disposed');
+        if (this.#listeners.size > 0) {
+            throw new Error('AelionPlayer supports one frame owner; unsubscribe before replacing it');
+        }
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    invalidate(changeSet) {
+        void changeSet;
+        const ir = this.#session.requireIr();
+        const timeUs = Math.min(Math.max(0, this.currentTimeUs), ir.durationUs - 1);
+        this.#advanceGeneration();
+        const clock = this.#clock;
+        if (clock instanceof AudioWorkletClock)
+            clock.resetForSeek(timeUs);
+        else
+            clock?.seek(timeUs);
+        this.#nextAudioFrame = sampleIndexAtTime(timeUs, ir.sampleRate);
+        this.#lastTimeUs = timeUs;
+        void this.#requestAudioFill(false);
+    }
+    async reset() {
+        if (this.#state === 'disposed')
+            return;
+        this.#advanceGeneration();
+        const generation = this.#generation;
+        await this.#disposeRuntime();
+        // The awaited runtime teardown permits a concurrent dispose() even though
+        // TypeScript narrows the pre-await state check.
+        if (this.#disposeTask !== undefined || generation !== this.#generation)
+            return;
+        this.#state = 'idle';
+        this.#lastTimeUs = 0;
+        this.#nextAudioFrame = 0;
+    }
+    dispose() {
+        this.#disposeTask ??= this.#dispose();
+        return this.#disposeTask;
+    }
+    async #dispose() {
+        if (this.#state === 'disposed')
+            return;
+        this.#advanceGeneration();
+        // Publish the terminal state before the first await so concurrent reset or
+        // runtime initialization cannot revive the Player while Session disposal runs.
+        this.#state = 'disposed';
+        this.#listeners.clear();
+        await this.#disposeRuntime();
+    }
+    async #ensureRuntime() {
+        if (this.#scheduler !== undefined)
+            return;
+        const existing = this.#runtimeInitTask;
+        if (existing !== undefined)
+            return existing;
+        const task = this.#initializeRuntime().finally(() => {
+            if (this.#runtimeInitTask === task)
+                this.#runtimeInitTask = undefined;
+        });
+        this.#runtimeInitTask = task;
+        return task;
+    }
+    async #initializeRuntime() {
+        const ir = this.#session.requireIr();
+        const generation = this.#generation;
+        const clock = globalThis.crossOriginIsolated && typeof SharedArrayBuffer === 'function'
+            ? new AudioWorkletClock({
+                capacityFrames: ir.sampleRate * 2,
+                channelCount: ir.channelLayout === 'mono' ? 1 : 2,
+                sampleRate: ir.sampleRate,
+                ...(this.#runtimeAssets?.sharedAudioWorklet === undefined
+                    ? {}
+                    : { moduleUrl: this.#runtimeAssets.sharedAudioWorklet }),
+            })
+            : new TransferableAudioWorkletClock({
+                capacityFrames: ir.sampleRate * 2,
+                channelCount: ir.channelLayout === 'mono' ? 1 : 2,
+                sampleRate: ir.sampleRate,
+                ...(this.#runtimeAssets?.transferableAudioWorklet === undefined
+                    ? {}
+                    : { moduleUrl: this.#runtimeAssets.transferableAudioWorklet }),
+            });
+        this.#clock = clock;
+        if (clock.context.sampleRate !== ir.sampleRate) {
+            const actual = clock.context.sampleRate;
+            await clock.dispose();
+            if (this.#clock === clock)
+                this.#clock = undefined;
+            throw new Error(`AudioContext sample rate ${actual.toString()} does not match Project ${ir.sampleRate.toString()}`);
+        }
+        try {
+            await clock.initialize(1_024);
+        }
+        catch (error) {
+            await clock.dispose().catch(() => undefined);
+            if (this.#clock === clock)
+                this.#clock = undefined;
+            throw error;
+        }
+        if (this.#clock !== clock || generation !== this.#generation || this.#state === 'disposed') {
+            await clock.dispose();
+            if (this.#clock === clock)
+                this.#clock = undefined;
+            throw new DOMException('Player runtime initialization became stale', 'AbortError');
+        }
+        this.#scheduler = new AudioDrivenVideoScheduler({
+            clock,
+            frameRate: ir.frameRate,
+            durationUs: ir.durationUs,
+            onFrame: scheduled => this.#renderScheduled(scheduled),
+            onError: error => this.#failRuntime(error),
+            onEnd: () => {
+                this.#state = 'ended';
+                this.#lastTimeUs = ir.durationUs;
+                if (this.#fillHandle !== undefined) {
+                    globalThis.clearInterval(this.#fillHandle);
+                    this.#fillHandle = undefined;
+                }
+                void this.#clock?.pause().catch((error) => this.#failRuntime(error));
+                this.#session.notifyStatsChanged();
+            },
+        });
+    }
+    #requestAudioFill(observeFailure) {
+        const existing = this.#fillTask;
+        if (existing !== undefined) {
+            if (this.#fillGeneration === this.#generation)
+                return existing;
+            const next = existing.then(() => this.#requestAudioFill(observeFailure), () => this.#requestAudioFill(observeFailure));
+            if (!observeFailure)
+                void next.catch((error) => this.#failRuntime(error));
+            return next;
+        }
+        const clock = this.#clock;
+        if (clock === undefined)
+            return Promise.resolve();
+        const generation = this.#generation;
+        const signal = this.#fillController.signal;
+        const task = this.#fillAudio(clock, generation, signal).finally(() => {
+            if (this.#fillTask === task)
+                this.#fillTask = undefined;
+        });
+        this.#fillTask = task;
+        this.#fillGeneration = generation;
+        if (!observeFailure)
+            void task.catch((error) => this.#failRuntime(error));
+        return task;
+    }
+    async #fillAudio(clock, generation, signal) {
+        const ir = this.#session.requireIr();
+        const channelCount = ir.channelLayout === 'mono' ? 1 : 2;
+        const totalFrames = Math.floor((ir.durationUs * ir.sampleRate) / 1_000_000);
+        while (this.#nextAudioFrame < totalFrames) {
+            if (!this.#runtimeCurrent(clock, generation, signal))
+                return;
+            const snapshot = clock instanceof AudioWorkletClock ? clock.ring.snapshot() : clock.snapshot();
+            const startFrame = this.#nextAudioFrame;
+            const frameCount = Math.min(4_096, snapshot.availableWriteFrames, totalFrames - startFrame);
+            if (frameCount <= 0)
+                break;
+            const pcm = await renderIrAudio({
+                ir,
+                startFrame,
+                frameCount,
+                channelCount,
+                source: this.#session.requireMedia(),
+                signal,
+            });
+            if (!this.#runtimeCurrent(clock, generation, signal))
+                return;
+            const accepted = clock instanceof AudioWorkletClock
+                ? clock.ring.writeInterleaved(pcm) === frameCount
+                : clock.enqueueInterleaved(pcm);
+            if (!accepted)
+                break;
+            if (this.#nextAudioFrame !== startFrame)
+                return;
+            this.#nextAudioFrame = startFrame + frameCount;
+        }
+    }
+    async #renderScheduled(scheduled) {
+        const signal = this.#videoController.signal;
+        const result = await this.#session.preview.renderFrame({
+            timeUs: scheduled.timestampUs,
+            signal,
+            ...this.#previewQuality,
+        });
+        if (signal.aborted || scheduled.generation !== this.#scheduler?.generation) {
+            result.bitmap.close();
+            return;
+        }
+        this.#publish(scheduled, result);
+    }
+    #publish(scheduled, result) {
+        this.#lastTimeUs = scheduled.timestampUs;
+        this.#renderedFrames += 1;
+        this.#droppedFrames += scheduled.droppedFrames;
+        this.#session.notifyStatsChanged();
+        if (this.#listeners.size === 0) {
+            result.bitmap.close();
+            return;
+        }
+        const event = { ...scheduled, result };
+        for (const listener of this.#listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                result.bitmap.close();
+                this.#failRuntime(error);
+                return;
+            }
+        }
+    }
+    #disposeRuntime() {
+        const existing = this.#runtimeDisposeTask;
+        if (existing !== undefined)
+            return existing;
+        const task = this.#disposeRuntimeOnce().finally(() => {
+            if (this.#runtimeDisposeTask === task)
+                this.#runtimeDisposeTask = undefined;
+        });
+        this.#runtimeDisposeTask = task;
+        return task;
+    }
+    async #disposeRuntimeOnce() {
+        if (this.#fillHandle !== undefined) {
+            globalThis.clearInterval(this.#fillHandle);
+            this.#fillHandle = undefined;
+        }
+        const scheduler = this.#scheduler;
+        const initializingClock = this.#clock;
+        scheduler?.dispose();
+        await this.#runtimeInitTask?.catch(() => undefined);
+        const clock = this.#clock ?? initializingClock;
+        this.#clock = undefined;
+        await clock?.dispose();
+        await this.#fillTask?.catch(() => undefined);
+        this.#fillTask = undefined;
+        this.#fillGeneration = -1;
+        this.#scheduler = undefined;
+        if (scheduler !== undefined || clock !== undefined) {
+            const transport = clock instanceof AudioWorkletClock
+                ? clock.ring.snapshot()
+                : clock instanceof TransferableAudioWorkletClock
+                    ? clock.snapshot()
+                    : undefined;
+            this.#lastDisposedRuntime = Object.freeze({
+                schedulerDisposed: scheduler?.snapshot().disposed ?? true,
+                audioDisposed: clock?.disposed ?? true,
+                audioContextClosed: clock === undefined || !clock.ownsContext || clock.context.state === 'closed',
+                transportClosed: transport === undefined
+                    ? true
+                    : 'state' in transport
+                        ? transport.state === 'closed'
+                        : transport.closed,
+                bufferedFrames: transport === undefined
+                    ? 0
+                    : 'availableReadFrames' in transport
+                        ? transport.availableReadFrames
+                        : transport.queuedFrames,
+            });
+        }
+    }
+    #advanceGeneration() {
+        this.#generation += 1;
+        this.#scheduler?.seek();
+        this.#fillController.abort(new DOMException('Player generation changed', 'AbortError'));
+        this.#videoController.abort(new DOMException('Player generation changed', 'AbortError'));
+        this.#fillController = new AbortController();
+        this.#videoController = new AbortController();
+    }
+    #runtimeCurrent(clock, generation, signal) {
+        return (!signal.aborted &&
+            this.#state !== 'disposed' &&
+            this.#clock === clock &&
+            this.#generation === generation);
+    }
+    #playContinuationCurrent(generation) {
+        return this.#disposeTask === undefined && generation === this.#generation;
+    }
+    #failRuntime(error) {
+        if (this.#state === 'disposed')
+            return;
+        if (error instanceof DOMException && error.name === 'AbortError')
+            return;
+        if (error !== null && typeof error === 'object') {
+            const diagnostics = Reflect.get(error, 'diagnostics');
+            if (Array.isArray(diagnostics) &&
+                diagnostics.some(value => value !== null &&
+                    typeof value === 'object' &&
+                    Reflect.get(value, 'code') === 'OPERATION_ABORTED')) {
+                return;
+            }
+        }
+        const failureTimeUs = this.currentTimeUs;
+        this.#errors += 1;
+        this.#lastErrorCode = runtimeErrorCode(error);
+        this.#state = 'error';
+        this.#lastTimeUs = failureTimeUs;
+        this.#scheduler?.pause();
+        if (this.#fillHandle !== undefined) {
+            globalThis.clearInterval(this.#fillHandle);
+            this.#fillHandle = undefined;
+        }
+        this.#fillController.abort(error);
+        void this.#clock?.pause().catch(() => undefined);
+        try {
+            this.#onRuntimeError?.(error);
+        }
+        catch {
+            // Error reporting cannot create a second unhandled runtime failure.
+        }
+        this.#session.notifyStatsChanged();
+    }
+}

package/dist/preview-controller.d.ts

@@ -0,0 +1,62 @@
+import type { AelionSessionApi } from './types.js';
+export type PreviewCanvasQuality = 'adaptive' | 'draft' | 'full';
+export interface PreviewCanvasControllerOptions {
+    readonly quality?: PreviewCanvasQuality;
+    readonly renderScale?: number;
+    readonly fit?: 'contain' | 'cover' | 'fill';
+    readonly background?: string;
+    readonly pixelRatio?: number;
+    /** Own Player frames and draw them to the Canvas. Defaults to true. */
+    readonly subscribePlayer?: boolean;
+    /** Pause playback while the page is hidden and resume it when visible. */
+    readonly pauseWhenHidden?: boolean;
+    readonly renderOnResize?: boolean;
+    readonly targetFrameMs?: number;
+    readonly adaptiveScales?: readonly number[];
+    readonly onPointer?: (event: PreviewCanvasPointerEvent) => void;
+    readonly onFrame?: (frame: PreviewCanvasFrame) => void;
+    readonly onError?: (error: unknown) => void;
+}
+export interface PreviewCanvasPoint {
+    readonly x: number;
+    readonly y: number;
+    readonly inside: boolean;
+}
+export interface PreviewCanvasPointerEvent {
+    readonly type: 'down' | 'move' | 'up' | 'cancel';
+    readonly point: PreviewCanvasPoint;
+    readonly pointerId: number;
+    readonly buttons: number;
+    readonly originalEvent: PointerEvent;
+}
+export interface PreviewCanvasFrame {
+    readonly timeUs: number;
+    readonly width: number;
+    readonly height: number;
+    readonly renderScale: number;
+    readonly backend: 'webgpu' | 'webgl2';
+}
+export interface PreviewCanvasControllerSnapshot {
+    readonly disposed: boolean;
+    readonly pending: boolean;
+    readonly generation: number;
+    readonly currentTimeUs: number | null;
+    readonly quality: PreviewCanvasQuality;
+    readonly renderScale: number;
+    readonly renderedFrames: number;
+    readonly cancelledFrames: number;
+    readonly failedFrames: number;
+    readonly canvasWidth: number;
+    readonly canvasHeight: number;
+}
+export interface PreviewCanvasController {
+    render(timeUs: number): Promise<void>;
+    setQuality(quality: PreviewCanvasQuality, renderScale?: number): void;
+    resize(): void;
+    toProjectPoint(clientX: number, clientY: number): PreviewCanvasPoint;
+    captureStream(frameRate?: number): MediaStream;
+    snapshot(): PreviewCanvasControllerSnapshot;
+    dispose(): void;
+}
+export declare function attachPreviewCanvas(session: AelionSessionApi, canvas: HTMLCanvasElement, options?: PreviewCanvasControllerOptions): PreviewCanvasController;
+//# sourceMappingURL=preview-controller.d.ts.map

package/dist/preview-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-controller.d.ts","sourceRoot":"","sources":["../src/preview-controller.ts"],"names":[],"mappings":"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"}