demuxe 0.3.0-beta.3

package/web/generated/internal/native-player.js

@@ -0,0 +1,502 @@
+/** Browser media ownership, including listeners, pending loads and object URLs. */
+export class NativePlayer extends EventTarget {
+    video;
+    remuxPolicy;
+    assetBase;
+    bufferedSeeks;
+    audioAdaptation;
+    initialAudioTrack;
+    nativeASS;
+    fonts;
+    ready = Promise.resolve();
+    properties = new Map();
+    stopped = false;
+    ass;
+    assAssets = [];
+    assIndex = -1;
+    gainContext;
+    gainSource;
+    gainNode;
+    gainValue = 1;
+    async gain(value) {
+        this.assertActive();
+        if (!Number.isFinite(value) || value < 0 || value > 1)
+            throw new Error('Gain must be between 0 and 1');
+        if (!this.gainSource && value !== 1) {
+            const context = this.gainContext ?? (this.gainContext = new AudioContext());
+            // Resume before redirecting an already playing element into the graph.
+            // Ownership is recorded before awaiting; destroy cancels the wait.
+            if (!this.video.paused)
+                await this.resumeGain();
+            this.assertActive();
+            const source = context.createMediaElementSource(this.video), gain = context.createGain();
+            gain.gain.setValueAtTime(value, context.currentTime);
+            source.connect(gain);
+            gain.connect(context.destination);
+            this.gainSource = source;
+            this.gainNode = gain;
+        }
+        if (this.gainNode)
+            this.gainNode.gain.setValueAtTime(value, this.gainContext.currentTime);
+        this.gainValue = value;
+    }
+    async resumeGain() {
+        const context = this.gainContext;
+        if (!context || context.state !== 'suspended')
+            return;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.cancelers.delete(cancel);
+                error ? reject(error) : resolve();
+            };
+            const cancel = (error) => finish(error);
+            const timer = setTimeout(() => finish(new DOMException('Audio activation timed out', 'NotAllowedError')), 10000);
+            this.cancelers.add(cancel);
+            context.resume().then(() => finish(), error => finish(error));
+        });
+        this.assertActive();
+    }
+    destruction;
+    opening = false;
+    remux;
+    adapted = false;
+    remuxSource;
+    directFailure;
+    shiftedCues = new WeakSet();
+    sourceTime() { return Math.max(0, this.video.currentTime - (this.remux?.timelineBias ?? 0)); }
+    sourceDuration() { if (this.remux?.windowed)
+        return this.remux.duration ?? 0; return Number.isFinite(this.video.duration) ? Math.max(0, this.video.duration - (this.remux?.timelineBias ?? 0)) : 0; }
+    objectURL;
+    selectedSub = 'auto';
+    subsVisible = true;
+    cancelers = new Set();
+    listeners = [];
+    constructor(video, remuxPolicy = 'auto', assetBase = new URL('../../../', import.meta.url), bufferedSeeks = false, audioAdaptation, initialAudioTrack, nativeASS = false, fonts = []) {
+        super();
+        this.video = video;
+        this.remuxPolicy = remuxPolicy;
+        this.assetBase = assetBase;
+        this.bufferedSeeks = bufferedSeeks;
+        this.audioAdaptation = audioAdaptation;
+        this.initialAudioTrack = initialAudioTrack;
+        this.nativeASS = nativeASS;
+        this.fonts = fonts;
+        video.playsInline = true;
+        video.preload = 'auto';
+        for (const event of ['timeupdate', 'durationchange', 'loadedmetadata', 'play', 'pause', 'volumechange', 'ratechange', 'ended', 'waiting', 'playing', 'progress', 'seeking', 'seeked', 'resize']) {
+            const listener = () => {
+                this.refresh();
+                this.emit('activity', event);
+                if (event === 'ended' && (!this.remux?.windowed || this.remux.playbackEnded))
+                    this.emit('mpv', { event: 'end-file', reason: 'eof' });
+            };
+            video.addEventListener(event, listener);
+            this.listeners.push(() => video.removeEventListener(event, listener));
+        }
+        const failed = () => { if (!this.opening && !this.remux?.starting && !this.stopped)
+            this.emit('error', `Native playback failed (${video.error?.code ?? 'unknown'}): ${video.error?.message ?? 'unsupported media or network failure'}`); };
+        video.addEventListener('error', failed);
+        this.listeners.push(() => video.removeEventListener('error', failed));
+        const tracks = () => this.refresh();
+        video.textTracks.addEventListener('change', tracks);
+        video.textTracks.addEventListener('addtrack', tracks);
+        this.listeners.push(() => { video.textTracks.removeEventListener('change', tracks); video.textTracks.removeEventListener('addtrack', tracks); });
+        this.refresh();
+    }
+    emit(type, detail) { this.dispatchEvent(new CustomEvent(type, { detail })); }
+    assertActive() { if (this.stopped)
+        throw new Error('Player is destroyed'); }
+    wait(event, start) {
+        this.assertActive();
+        return new Promise((resolve, reject) => {
+            const finish = (error) => {
+                clearTimeout(timer);
+                this.video.removeEventListener(event, done);
+                this.video.removeEventListener('error', failed);
+                this.cancelers.delete(cancel);
+                error ? reject(error) : resolve();
+            };
+            const done = () => finish();
+            const failed = () => finish(new Error(`Native media operation failed: ${this.video.error?.message || this.video.error?.code}`));
+            const cancel = (error) => finish(error);
+            const timer = setTimeout(() => finish(new Error(`Native ${event} timed out`)), 25000);
+            this.cancelers.add(cancel);
+            this.video.addEventListener(event, done, { once: true });
+            this.video.addEventListener('error', failed, { once: true });
+            try {
+                start();
+            }
+            catch (error) {
+                finish(error);
+            }
+        });
+    }
+    refresh() {
+        const tracks = Array.from(this.video.textTracks, (t, i) => ({ id: String(i + 1), type: 'sub', title: t.label, lang: t.language, selected: t.mode === 'showing' }));
+        tracks.push(...this.assAssets.map((a, i) => ({ id: String(100001 + i), type: 'sub', codec: a.format, title: a.label, lang: a.language, external: true, 'external-index': i + 1, selected: (this.selectedSub === 'auto' || Number(this.selectedSub) === 100001 + i) && this.assIndex === i })));
+        const audio = this.video.audioTracks;
+        if (this.remux?.tracks)
+            tracks.push(...this.remux.tracks.filter(t => t.type === 'audio').map(t => ({ ...t, selected: t.selected && !this.video.muted })));
+        else if (audio)
+            tracks.push(...Array.from(audio, (t, i) => ({ id: String(i + 1), type: 'audio', title: t.label, lang: t.language, selected: t.enabled })));
+        const timeRanges = (r) => Array.from({ length: r.length }, (_, i) => ({ start: Math.max(0, r.start(i) - (this.remux?.timelineBias ?? 0)), end: Math.max(0, r.end(i) - (this.remux?.timelineBias ?? 0)) }));
+        const values = { 'time-pos': this.sourceTime(), duration: Number.isFinite(this.video.duration) ? this.sourceDuration() : null, 'native-buffered': this.remux?.windowed ? (this.remux.ranges?.() ?? []).map(([start, end]) => ({ start, end })) : timeRanges(this.video.buffered), 'native-seekable': this.remux?.windowed ? [{ start: 0, end: this.sourceDuration() }] : timeRanges(this.video.seekable), 'native-live': this.video.duration === Infinity, pause: this.remux?.playbackPaused ?? this.video.paused, 'eof-reached': this.remux?.playbackEnded ?? this.video.ended, volume: this.video.volume * 100, speed: this.video.playbackRate, 'track-list': tracks };
+        for (const [name, data] of Object.entries(values)) {
+            if (name !== 'track-list' && this.properties.get(name) === data)
+                continue;
+            this.properties.set(name, data);
+            this.emit('mpv', { event: 'property-change', name, data });
+        }
+    }
+    get diagnostics() { const q = this.video.getVideoPlaybackQuality(); return { path: 'native', plan: this.remux ? (this.adapted ? `adapted-${this.audioAdaptation}` : 'remux') : 'direct', subtitleOverlay: this.ass ? { component: 'libass', scope: 'external-ass', destination: 'container-only', ...this.ass.stats } : undefined, audioProcessing: { component: this.gainContext ? 'web-audio-gain' : 'media-element', gain: this.gainValue, contextState: this.gainContext?.state, baseLatency: this.gainContext?.baseLatency }, directFailure: this.directFailure, remux: this.remux?.snapshot(), position: this.sourceTime(), rendered: q.totalVideoFrames, dropped: q.droppedVideoFrames, readyState: this.video.readyState }; }
+    async load(url) {
+        await this.wait('loadeddata', () => { this.video.src = url; this.video.load(); });
+        this.refresh();
+        this.emit('mpv', { event: 'file-loaded' });
+    }
+    async startRemux(source, target = 0) {
+        this.assertActive();
+        if (!crossOriginIsolated || typeof MediaSource === 'undefined')
+            throw Error('Native remux requires MediaSource and cross-origin isolation');
+        if (source.options?.format && source.options.format !== 'file')
+            throw Error('Native remux currently requires a random-access file source; use Hybrid for this manifest');
+        const moduleURL = new URL('web/native-remux-player.js', this.assetBase).href;
+        const { RemuxPlayer } = await import(moduleURL);
+        this.assertActive();
+        const { refreshAuthorization, ...options } = source.options ?? {};
+        const transport = { ...source, ...(source.options ? { options: options } : {}), refreshAuthorization };
+        const attempt = async (adapted) => {
+            this.assertActive();
+            this.adapted = adapted;
+            this.remux ??= new RemuxPlayer(this.video, { bufferedSeeks: this.bufferedSeeks, audioAdaptation: adapted ? this.audioAdaptation : undefined });
+            this.remux.audioAdaptation = adapted ? this.audioAdaptation : undefined;
+            this.remux.onError = message => { if (!this.opening && !this.stopped)
+                this.emit('error', message); };
+            await this.remux.open(transport, target);
+            this.assertActive();
+        };
+        try {
+            await attempt(false);
+        }
+        catch (error) {
+            if (this.stopped || !this.audioAdaptation || !String(error).includes('Audio codec has no browser MP4 packet contract'))
+                throw error;
+            await attempt(true);
+        }
+        this.remuxSource = source;
+        if (this.video.seeking)
+            await this.wait('seeked', () => { });
+        this.refresh();
+        this.emit('source', { plan: this.adapted ? `adapted-${this.audioAdaptation}` : 'remux', tracks: this.remux.tracks });
+        this.emit('mpv', { event: 'file-loaded' });
+    }
+    async loadPlan(source, direct, requiresRemux = false) {
+        this.assertActive();
+        this.opening = true;
+        try {
+            if (this.remuxPolicy !== 'always' && !requiresRemux) {
+                try {
+                    await direct();
+                    return;
+                }
+                catch (error) {
+                    if (this.stopped || this.remuxPolicy === 'never' || ![3, 4].includes(this.video.error?.code ?? 0))
+                        throw error;
+                    this.directFailure = String(error);
+                }
+            }
+            else if (this.remuxPolicy === 'never')
+                throw Error('Native direct cannot enforce these source permissions; enable native remux or choose Hybrid');
+            await this.startRemux(source);
+        }
+        finally {
+            this.opening = false;
+        }
+    }
+    async open(file) {
+        this.assertActive();
+        const local = file instanceof File ? file : new File([file], 'media');
+        this.objectURL = URL.createObjectURL(local);
+        try {
+            await this.loadPlan({ file: local, audioTrack: this.initialAudioTrack }, () => this.load(this.objectURL));
+        }
+        catch (error) {
+            URL.revokeObjectURL(this.objectURL);
+            this.objectURL = undefined;
+            throw error;
+        }
+    }
+    async openRemote(source) {
+        this.assertActive();
+        const url = new URL(source.url, location.href);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw Error('Remote sources require HTTP or HTTPS');
+        const requiresRemux = !!(source.headers || source.refreshAuthorization || source.allowedOrigins || source.immutable !== undefined || source.credentials === 'omit');
+        this.video.crossOrigin = source.credentials === 'include' ? 'use-credentials' : 'anonymous';
+        await this.loadPlan({ options: { ...source, url: url.href }, audioTrack: this.initialAudioTrack }, async () => {
+            if (source.format && source.format !== 'file') {
+                const mime = source.format === 'hls' ? 'application/vnd.apple.mpegurl' : 'application/dash+xml';
+                if (!this.video.canPlayType(mime))
+                    throw Error(`Native ${source.format.toUpperCase()} playback is not supported by this browser`);
+            }
+            await this.load(url.href);
+        }, requiresRemux);
+    }
+    async play() { this.assertActive(); await this.resumeGain(); this.assertActive(); if (this.remux)
+        await this.remux.play();
+    else
+        await this.video.play(); this.refresh(); }
+    async pause() { this.assertActive(); if (this.remux)
+        this.remux.pause();
+    else
+        this.video.pause(); this.refresh(); }
+    async seek(seconds) {
+        this.assertActive();
+        if (this.remux) {
+            const paused = this.remux.playbackPaused ?? this.video.paused;
+            if (this.remux.canSeekBuffered?.(seconds) && this.video.videoWidth && Math.abs(this.sourceTime() - seconds) > .001) {
+                // Hold the presentation clock while verifying the target frame. Otherwise
+                // a playing clock can advance beyond the exact target before rVFC runs.
+                // Producer/session identity is retained; restore the captured intent below.
+                this.remux.pause();
+                await this.seekPresented(seconds, () => this.remux.seek(seconds));
+            }
+            else
+                await this.remux.seek(seconds);
+            this.assertActive();
+            if (this.video.seeking)
+                await this.wait('seeked', () => { });
+            if (!paused)
+                await this.remux.play();
+            this.refresh();
+            return;
+        }
+        if (Math.abs(this.video.currentTime - seconds) < .001 && !this.video.seeking)
+            return;
+        await this.wait('seeked', () => { this.video.currentTime = seconds; });
+        this.refresh();
+    }
+    seekPresented(target, action) {
+        return new Promise((resolve, reject) => {
+            let frame = 0, accepted = false, completed = false, finished = false;
+            const presentation = this.remux, generation = presentation?.generation, mediaTarget = target + (presentation?.timelineBias ?? 0), expected = presentation?.expectedVideoFrame?.(target);
+            const correlated = !!presentation?.muxedFrames || expected !== undefined;
+            let presented = false;
+            const seeked = () => { if (this.stopped || this.remux !== presentation || presentation?.generation !== generation) {
+                finish(new Error('Native seek presentation was retired'));
+                return;
+            } if (correlated && presented && !this.video.seeking && Math.abs(this.video.currentTime - mediaTarget) < .001) {
+                accepted = true;
+                if (completed)
+                    finish();
+            } };
+            const finish = (error) => { if (finished)
+                return; finished = true; clearTimeout(timer); this.video.cancelVideoFrameCallback(frame); this.video.removeEventListener('seeked', seeked); this.cancelers.delete(cancel); error ? reject(error) : resolve(); };
+            const cancel = (error) => finish(error);
+            const timer = setTimeout(() => finish(new Error('Native seek did not present the target')), 10000);
+            const next = (_, metadata) => {
+                if (this.stopped || this.remux !== presentation || presentation?.generation !== generation) {
+                    finish(new Error('Native seek presentation was retired'));
+                    return;
+                }
+                // A browser may report the frame's PTS or clip that timestamp to the seek
+                // point (Firefox). Accept only the corresponding source-frame interval.
+                // Legacy remux artifacts without packet metadata retain their prior guard.
+                const matches = presentation?.matchesVideoFrame?.(target, metadata.mediaTime) ?? (expected !== undefined && metadata.mediaTime >= expected + (presentation?.timelineBias ?? 0) - .001 && metadata.mediaTime <= mediaTarget + .001);
+                if (correlated && matches && Math.abs(this.video.currentTime - mediaTarget) < .001)
+                    presented = true;
+                if (!this.video.seeking && Math.abs(this.video.currentTime - mediaTarget) < .001 && (correlated ? presented : metadata.mediaTime <= mediaTarget + .001)) {
+                    accepted = true;
+                    if (completed)
+                        finish();
+                }
+                else
+                    frame = this.video.requestVideoFrameCallback(next);
+            };
+            // Register before currentTime changes: the compositor callback may precede
+            // the queued DOM seeking/seeked events, especially for buffered media.
+            this.cancelers.add(cancel);
+            this.video.addEventListener('seeked', seeked);
+            frame = this.video.requestVideoFrameCallback(next);
+            Promise.resolve().then(action).then(() => { completed = true; if (accepted)
+                finish(); }, error => finish(error));
+        });
+    }
+    async rate(value) { this.assertActive(); this.video.defaultPlaybackRate = value; this.video.playbackRate = value; this.refresh(); }
+    async volume(value) { this.assertActive(); this.video.volume = value / 100; this.refresh(); }
+    async selectTrack(type, id) {
+        this.assertActive();
+        if (type === 'audio') {
+            const audio = this.video.audioTracks;
+            if (id === 'auto') {
+                this.video.muted = false;
+                return;
+            }
+            if (id === 'no') {
+                this.video.muted = true;
+                return;
+            }
+            if (this.remux && this.remuxSource) {
+                const track = this.remux.tracks?.find(t => t.type === 'audio' && t.id === id);
+                if (!track)
+                    throw Error('Unknown remux audio track');
+                if (!track.selected) {
+                    const previous = this.remuxSource, position = this.sourceTime(), paused = this.video.paused;
+                    this.opening = true;
+                    try {
+                        await this.startRemux({ ...previous, audioTrack: Number(id) - 1 }, position);
+                    }
+                    catch (error) {
+                        try {
+                            await this.startRemux(previous, position);
+                        }
+                        catch (recovery) {
+                            this.emit('error', String(recovery));
+                        }
+                        throw error;
+                    }
+                    finally {
+                        this.opening = false;
+                        if (!paused)
+                            await this.video.play();
+                    }
+                }
+                this.video.muted = false;
+                this.refresh();
+                return;
+            }
+            if (!audio || !audio[Number(id) - 1])
+                throw new Error('Native audio track selection is not supported for this source/browser');
+            this.video.muted = false;
+            Array.from(audio).forEach((t, i) => { t.enabled = i === Number(id) - 1; });
+        }
+        else {
+            if (Number(id) >= 100001) {
+                const index = Number(id) - 100001;
+                if (!this.assAssets[index])
+                    throw Error('Unknown Native ASS track');
+                await this.ass.load(this.assAssets[index]);
+                this.assIndex = index;
+            }
+            if (!['auto', 'no'].includes(id) && !this.assAssets[Number(id) - 100001] && !this.video.textTracks[Number(id) - 1])
+                throw new Error('Unknown native subtitle track');
+            this.selectedSub = id;
+            this.applySubtitles();
+        }
+        this.refresh();
+    }
+    applySubtitles() {
+        this.ass?.visible(this.assIndex >= 0 && this.subsVisible && this.selectedSub !== 'no' && (this.selectedSub === 'auto' || Number(this.selectedSub) >= 100001));
+        const preferred = this.video.querySelector('track[default]')?.track;
+        const autoIndex = Math.max(0, Array.from(this.video.textTracks).findIndex(t => t === preferred));
+        Array.from(this.video.textTracks).forEach((t, i) => { t.mode = this.subsVisible && !(this.assIndex >= 0 && this.selectedSub === 'auto') && this.selectedSub !== 'no' && (this.selectedSub === 'auto' ? i === autoIndex : i === Number(this.selectedSub) - 1) ? 'showing' : 'disabled'; });
+    }
+    async subtitleVisible(visible) { this.assertActive(); this.subsVisible = visible; this.applySubtitles(); this.refresh(); }
+    async addSubtitle(asset) {
+        this.assertActive();
+        if (this.adapted && this.audioAdaptation === 'opus')
+            throw Error('Native Opus plus ASS is not qualified');
+        if (!this.nativeASS || !['ass', 'ssa'].includes(asset.format))
+            throw Error('Native external ASS/SSA requires explicit experimental admission');
+        if (this.assAssets.length >= 16 || asset.bytes.byteLength > 8 * 1024 * 1024 || this.assAssets.reduce((n, a) => n + a.bytes.byteLength, 0) + asset.bytes.byteLength > 16 * 1024 * 1024)
+            throw Error('Subtitle budget exceeded');
+        if (!this.ass) {
+            const { NativeASS } = await import('./native-ass.js');
+            this.assertActive();
+            this.ass = new NativeASS(this.video, () => this.sourceTime(), this.assetBase, this.fonts, error => { if (!this.stopped)
+                this.emit('error', String(error)); });
+        }
+        if (asset.select) {
+            try {
+                await this.ass.load(asset);
+                this.assertActive();
+            }
+            catch (error) {
+                this.ass.destroy();
+                this.ass = undefined;
+                throw error;
+            }
+            this.assIndex = this.assAssets.length;
+        }
+        this.assAssets.push(asset);
+        this.applySubtitles();
+        this.refresh();
+    }
+    async addTextTrack(source) {
+        this.assertActive();
+        const url = new URL(source.src, location.href);
+        if (!['http:', 'https:', 'blob:'].includes(url.protocol))
+            throw new Error('Text tracks require HTTP, HTTPS or a blob URL');
+        const track = document.createElement('track');
+        track.kind = 'subtitles';
+        track.label = source.label;
+        track.srclang = source.language || '';
+        track.default = !!source.default;
+        track.src = url.href;
+        await new Promise((resolve, reject) => {
+            const finish = (error) => { clearTimeout(timer); track.removeEventListener('load', loaded); track.removeEventListener('error', failed); this.cancelers.delete(cancel); if (error) {
+                track.remove();
+                reject(error);
+            }
+            else
+                resolve(); };
+            const loaded = () => { this.shiftTextTrack(track); finish(); };
+            const failed = () => finish(new Error('Native text track failed to load'));
+            const cancel = (error) => finish(error);
+            const timer = setTimeout(() => finish(new Error('Native text track load timed out')), 15000);
+            this.cancelers.add(cancel);
+            track.addEventListener('load', loaded);
+            track.addEventListener('error', failed);
+            this.video.append(track);
+            track.addEventListener('load', () => this.shiftTextTrack(track));
+            track.track.mode = 'hidden';
+        });
+        this.applySubtitles();
+        this.refresh();
+    }
+    shiftTextTrack(track) {
+        if (!this.remux)
+            return;
+        for (const cue of Array.from(track.track.cues ?? []))
+            if (!this.shiftedCues.has(cue)) {
+                cue.startTime += this.remux.timelineBias;
+                cue.endTime += this.remux.timelineBias;
+                this.shiftedCues.add(cue);
+            }
+    }
+    resize(width, height) { this.assertActive(); this.video.width = width; this.video.height = height; }
+    audioDiagnostics() { return { state: this.stopped ? 'closed' : this.video.paused ? 'paused' : 'running', source: 'native', decodedSampleCountersAvailable: false }; }
+    destroy() {
+        if (this.destruction)
+            return this.destruction;
+        this.destruction = this.dispose();
+        return this.destruction;
+    }
+    async dispose() {
+        this.stopped = true;
+        this.ass?.destroy();
+        this.ass = undefined;
+        this.assAssets = [];
+        for (const cancel of this.cancelers)
+            cancel(new Error('Player is destroyed'));
+        await this.remux?.destroy();
+        this.gainSource?.disconnect();
+        this.gainNode?.disconnect();
+        if (this.gainContext)
+            await this.gainContext.close();
+        this.listeners.forEach(remove => remove());
+        this.listeners = [];
+        this.video.pause();
+        this.video.removeAttribute('src');
+        this.video.replaceChildren();
+        this.video.load();
+        if (this.objectURL)
+            URL.revokeObjectURL(this.objectURL);
+        this.objectURL = undefined;
+    }
+}