@remotion/media 4.0.355 → 4.0.357

package/dist/video/media-player.js

@@ -0,0 +1,484 @@
+import { ALL_FORMATS, AudioBufferSink, CanvasSink, Input, UrlSource, } from 'mediabunny';
+import { Internals } from 'remotion';
+import { isNetworkError } from '../is-network-error';
+import { resolvePlaybackTime } from './resolve-playback-time';
+import { sleep, withTimeout } from './timeout-utils';
+export const SEEK_THRESHOLD = 0.05;
+const AUDIO_BUFFER_TOLERANCE_THRESHOLD = 0.1;
+export class MediaPlayer {
+    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBeforeSeconds, trimAfterSeconds, playbackRate, audioStreamIndex, }) {
+        this.canvasSink = null;
+        this.videoFrameIterator = null;
+        this.nextFrame = null;
+        this.audioSink = null;
+        this.audioBufferIterator = null;
+        this.queuedAudioNodes = new Set();
+        this.gainNode = null;
+        // audioDelay = mediaTimestamp + audioSyncAnchor - sharedAudioContext.currentTime
+        this.audioSyncAnchor = 0;
+        this.playing = false;
+        this.muted = false;
+        this.loop = false;
+        this.animationFrameId = null;
+        this.videoAsyncId = 0;
+        this.audioAsyncId = 0;
+        this.initialized = false;
+        // for remotion buffer state
+        this.isBuffering = false;
+        this.audioBufferHealth = 0;
+        this.audioIteratorStarted = false;
+        this.HEALTHY_BUFER_THRESHOLD_SECONDS = 1;
+        this.input = null;
+        this.render = () => {
+            if (this.isBuffering) {
+                this.maybeForceResumeFromBuffering();
+            }
+            if (this.shouldRenderFrame()) {
+                this.drawCurrentFrame();
+            }
+            if (this.playing) {
+                this.animationFrameId = requestAnimationFrame(this.render);
+            }
+            else {
+                this.animationFrameId = null;
+            }
+        };
+        this.startAudioIterator = async (startFromSecond) => {
+            if (!this.hasAudio())
+                return;
+            this.audioAsyncId++;
+            const currentAsyncId = this.audioAsyncId;
+            // Clean up existing audio iterator
+            await this.audioBufferIterator?.return();
+            this.audioIteratorStarted = false;
+            this.audioBufferHealth = 0;
+            try {
+                this.audioBufferIterator = this.audioSink.buffers(startFromSecond);
+                this.runAudioIterator(startFromSecond, currentAsyncId);
+            }
+            catch (error) {
+                Internals.Log.error({ logLevel: this.logLevel, tag: '@remotion/media' }, '[MediaPlayer] Failed to start audio iterator', error);
+            }
+        };
+        this.startVideoIterator = async (timeToSeek) => {
+            if (!this.canvasSink) {
+                return;
+            }
+            this.videoAsyncId++;
+            const currentAsyncId = this.videoAsyncId;
+            this.videoFrameIterator?.return().catch(() => undefined);
+            this.videoFrameIterator = this.canvasSink.canvases(timeToSeek);
+            try {
+                const firstFrame = (await this.videoFrameIterator.next()).value ?? null;
+                const secondFrame = (await this.videoFrameIterator.next()).value ?? null;
+                if (currentAsyncId !== this.videoAsyncId) {
+                    return;
+                }
+                if (firstFrame && this.context) {
+                    Internals.Log.trace({ logLevel: this.logLevel, tag: '@remotion/media' }, `[MediaPlayer] Drew initial frame ${firstFrame.timestamp.toFixed(3)}s`);
+                    this.context.drawImage(firstFrame.canvas, 0, 0);
+                    if (this.onVideoFrameCallback && this.canvas) {
+                        this.onVideoFrameCallback(this.canvas);
+                    }
+                }
+                this.nextFrame = secondFrame ?? null;
+                if (secondFrame) {
+                    Internals.Log.trace({ logLevel: this.logLevel, tag: '@remotion/media' }, `[MediaPlayer] Buffered next frame ${secondFrame.timestamp.toFixed(3)}s`);
+                }
+            }
+            catch (error) {
+                Internals.Log.error({ logLevel: this.logLevel, tag: '@remotion/media' }, '[MediaPlayer] Failed to start video iterator', error);
+            }
+        };
+        this.updateNextFrame = async () => {
+            if (!this.videoFrameIterator) {
+                return;
+            }
+            try {
+                while (true) {
+                    const newNextFrame = (await this.videoFrameIterator.next()).value ?? null;
+                    if (!newNextFrame) {
+                        break;
+                    }
+                    if (newNextFrame.timestamp <= this.getPlaybackTime()) {
+                        continue;
+                    }
+                    else {
+                        this.nextFrame = newNextFrame;
+                        Internals.Log.trace({ logLevel: this.logLevel, tag: '@remotion/media' }, `[MediaPlayer] Buffered next frame ${newNextFrame.timestamp.toFixed(3)}s`);
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                Internals.Log.error({ logLevel: this.logLevel, tag: '@remotion/media' }, '[MediaPlayer] Failed to update next frame', error);
+            }
+        };
+        this.bufferingStartedAtMs = null;
+        this.minBufferingTimeoutMs = 500;
+        this.runAudioIterator = async (startFromSecond, audioAsyncId) => {
+            if (!this.hasAudio() || !this.audioBufferIterator)
+                return;
+            try {
+                let totalBufferDuration = 0;
+                let isFirstBuffer = true;
+                this.audioIteratorStarted = true;
+                while (true) {
+                    if (audioAsyncId !== this.audioAsyncId) {
+                        return;
+                    }
+                    const BUFFERING_TIMEOUT_MS = 50;
+                    let result;
+                    try {
+                        result = await withTimeout(this.audioBufferIterator.next(), BUFFERING_TIMEOUT_MS, 'Iterator timeout');
+                    }
+                    catch {
+                        this.setBufferingState(true);
+                        await sleep(10);
+                        continue;
+                    }
+                    if (result.done || !result.value) {
+                        break;
+                    }
+                    const { buffer, timestamp, duration } = result.value;
+                    totalBufferDuration += duration;
+                    this.audioBufferHealth = Math.max(0, totalBufferDuration / this.playbackRate);
+                    this.maybeResumeFromBuffering(totalBufferDuration / this.playbackRate);
+                    if (this.playing && !this.muted) {
+                        if (isFirstBuffer) {
+                            this.audioSyncAnchor =
+                                this.sharedAudioContext.currentTime - timestamp;
+                            isFirstBuffer = false;
+                        }
+                        // if timestamp is less than timeToSeek, skip
+                        // context: for some reason, mediabunny returns buffer at 9.984s, when requested at 10s
+                        if (timestamp < startFromSecond - AUDIO_BUFFER_TOLERANCE_THRESHOLD) {
+                            continue;
+                        }
+                        this.scheduleAudioChunk(buffer, timestamp);
+                    }
+                    if (timestamp - this.getPlaybackTime() >= 1) {
+                        await new Promise((resolve) => {
+                            const check = () => {
+                                if (timestamp - this.getPlaybackTime() < 1) {
+                                    resolve();
+                                }
+                                else {
+                                    requestAnimationFrame(check);
+                                }
+                            };
+                            check();
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                Internals.Log.error({ logLevel: this.logLevel, tag: '@remotion/media' }, '[MediaPlayer] Failed to run audio iterator', error);
+            }
+        };
+        this.canvas = canvas ?? null;
+        this.src = src;
+        this.logLevel = logLevel ?? window.remotion_logLevel;
+        this.sharedAudioContext = sharedAudioContext;
+        this.playbackRate = playbackRate;
+        this.loop = loop;
+        this.trimBeforeSeconds = trimBeforeSeconds;
+        this.trimAfterSeconds = trimAfterSeconds;
+        this.audioStreamIndex = audioStreamIndex ?? 0;
+        if (canvas) {
+            const context = canvas.getContext('2d', {
+                alpha: false,
+                desynchronized: true,
+            });
+            if (!context) {
+                throw new Error('Could not get 2D context from canvas');
+            }
+            this.context = context;
+        }
+        else {
+            this.context = null;
+        }
+    }
+    isReady() {
+        return this.initialized && Boolean(this.sharedAudioContext);
+    }
+    hasAudio() {
+        return Boolean(this.audioSink && this.sharedAudioContext && this.gainNode);
+    }
+    isCurrentlyBuffering() {
+        return this.isBuffering && Boolean(this.bufferingStartedAtMs);
+    }
+    async initialize(startTimeUnresolved) {
+        try {
+            const urlSource = new UrlSource(this.src);
+            const input = new Input({
+                source: urlSource,
+                formats: ALL_FORMATS,
+            });
+            this.input = input;
+            try {
+                await this.input.getFormat();
+            }
+            catch (error) {
+                const err = error;
+                if (isNetworkError(err)) {
+                    throw error;
+                }
+                Internals.Log.error({ logLevel: this.logLevel, tag: '@remotion/media' }, `[MediaPlayer] Failed to recognize format for ${this.src}`, error);
+                return { type: 'unknown-container-format' };
+            }
+            const [duration, videoTrack, audioTracks] = await Promise.all([
+                input.computeDuration(),
+                input.getPrimaryVideoTrack(),
+                input.getAudioTracks(),
+            ]);
+            this.totalDuration = duration;
+            const audioTrack = audioTracks[this.audioStreamIndex] ?? null;
+            if (!videoTrack && !audioTrack) {
+                return { type: 'no-tracks' };
+            }
+            if (videoTrack && this.canvas && this.context) {
+                const canDecode = await videoTrack.canDecode();
+                if (!canDecode) {
+                    return { type: 'cannot-decode' };
+                }
+                this.canvasSink = new CanvasSink(videoTrack, {
+                    poolSize: 2,
+                    fit: 'contain',
+                });
+                this.canvas.width = videoTrack.displayWidth;
+                this.canvas.height = videoTrack.displayHeight;
+            }
+            if (audioTrack && this.sharedAudioContext) {
+                this.audioSink = new AudioBufferSink(audioTrack);
+                this.gainNode = this.sharedAudioContext.createGain();
+                this.gainNode.connect(this.sharedAudioContext.destination);
+            }
+            const startTime = resolvePlaybackTime({
+                absolutePlaybackTimeInSeconds: startTimeUnresolved,
+                playbackRate: this.playbackRate,
+                loop: this.loop,
+                trimBeforeInSeconds: this.trimBeforeSeconds,
+                trimAfterInSeconds: this.trimAfterSeconds,
+                mediaDurationInSeconds: this.totalDuration,
+            });
+            if (this.sharedAudioContext) {
+                this.audioSyncAnchor = this.sharedAudioContext.currentTime - startTime;
+            }
+            this.initialized = true;
+            await Promise.all([
+                this.startAudioIterator(startTime),
+                this.startVideoIterator(startTime),
+            ]);
+            this.startRenderLoop();
+            return { type: 'success' };
+        }
+        catch (error) {
+            const err = error;
+            if (isNetworkError(err)) {
+                Internals.Log.error({ logLevel: this.logLevel, tag: '@remotion/media' }, `[MediaPlayer] Network/CORS error for ${this.src}`, err);
+                return { type: 'network-error' };
+            }
+            Internals.Log.error({ logLevel: this.logLevel, tag: '@remotion/media' }, '[MediaPlayer] Failed to initialize', error);
+            throw error;
+        }
+    }
+    cleanupAudioQueue() {
+        for (const node of this.queuedAudioNodes) {
+            node.stop();
+        }
+        this.queuedAudioNodes.clear();
+    }
+    async cleanAudioIteratorAndNodes() {
+        await this.audioBufferIterator?.return();
+        this.audioBufferIterator = null;
+        this.audioIteratorStarted = false;
+        this.audioBufferHealth = 0;
+        this.cleanupAudioQueue();
+    }
+    async seekTo(time) {
+        if (!this.isReady())
+            return;
+        const newTime = resolvePlaybackTime({
+            absolutePlaybackTimeInSeconds: time,
+            playbackRate: this.playbackRate,
+            loop: this.loop,
+            trimBeforeInSeconds: this.trimBeforeSeconds,
+            trimAfterInSeconds: this.trimAfterSeconds,
+            mediaDurationInSeconds: this.totalDuration,
+        });
+        const currentPlaybackTime = this.getPlaybackTime();
+        const isSignificantSeek = Math.abs(newTime - currentPlaybackTime) > SEEK_THRESHOLD;
+        if (isSignificantSeek) {
+            this.nextFrame = null;
+            this.audioSyncAnchor = this.sharedAudioContext.currentTime - newTime;
+            if (this.audioSink) {
+                await this.cleanAudioIteratorAndNodes();
+            }
+            await Promise.all([
+                this.startAudioIterator(newTime),
+                this.startVideoIterator(newTime),
+            ]);
+        }
+        if (!this.playing) {
+            this.render();
+        }
+    }
+    async play() {
+        if (!this.isReady())
+            return;
+        if (!this.playing) {
+            if (this.sharedAudioContext.state === 'suspended') {
+                await this.sharedAudioContext.resume();
+            }
+            this.playing = true;
+            this.startRenderLoop();
+        }
+    }
+    pause() {
+        this.playing = false;
+        this.cleanupAudioQueue();
+        this.stopRenderLoop();
+    }
+    setMuted(muted) {
+        this.muted = muted;
+        if (muted) {
+            this.cleanupAudioQueue();
+        }
+    }
+    setVolume(volume) {
+        if (!this.gainNode) {
+            return;
+        }
+        const appliedVolume = Math.max(0, volume);
+        this.gainNode.gain.value = appliedVolume;
+    }
+    setPlaybackRate(rate) {
+        this.playbackRate = rate;
+    }
+    setLoop(loop) {
+        this.loop = loop;
+    }
+    dispose() {
+        this.input?.dispose();
+        this.stopRenderLoop();
+        this.videoFrameIterator?.return();
+        this.cleanAudioIteratorAndNodes();
+        this.videoAsyncId++;
+    }
+    getPlaybackTime() {
+        const absoluteTime = this.sharedAudioContext.currentTime - this.audioSyncAnchor;
+        return resolvePlaybackTime({
+            absolutePlaybackTimeInSeconds: absoluteTime,
+            playbackRate: this.playbackRate,
+            loop: this.loop,
+            trimBeforeInSeconds: this.trimBeforeSeconds,
+            trimAfterInSeconds: this.trimAfterSeconds,
+            mediaDurationInSeconds: this.totalDuration,
+        });
+    }
+    scheduleAudioChunk(buffer, mediaTimestamp) {
+        const targetTime = mediaTimestamp + this.audioSyncAnchor;
+        const delay = targetTime - this.sharedAudioContext.currentTime;
+        const node = this.sharedAudioContext.createBufferSource();
+        node.buffer = buffer;
+        node.playbackRate.value = this.playbackRate;
+        node.connect(this.gainNode);
+        if (delay >= 0) {
+            node.start(targetTime);
+        }
+        else {
+            node.start(this.sharedAudioContext.currentTime, -delay);
+        }
+        this.queuedAudioNodes.add(node);
+        node.onended = () => this.queuedAudioNodes.delete(node);
+    }
+    onBufferingChange(callback) {
+        this.onBufferingChangeCallback = callback;
+        return () => {
+            if (this.onBufferingChangeCallback === callback) {
+                this.onBufferingChangeCallback = undefined;
+            }
+        };
+    }
+    onVideoFrame(callback) {
+        this.onVideoFrameCallback = callback;
+        if (this.initialized && callback && this.canvas) {
+            callback(this.canvas);
+        }
+        return () => {
+            if (this.onVideoFrameCallback === callback) {
+                this.onVideoFrameCallback = undefined;
+            }
+        };
+    }
+    canRenderVideo() {
+        return (!this.hasAudio() ||
+            (this.audioIteratorStarted &&
+                this.audioBufferHealth >= this.HEALTHY_BUFER_THRESHOLD_SECONDS));
+    }
+    startRenderLoop() {
+        if (this.animationFrameId !== null) {
+            return;
+        }
+        this.render();
+    }
+    stopRenderLoop() {
+        if (this.animationFrameId !== null) {
+            cancelAnimationFrame(this.animationFrameId);
+            this.animationFrameId = null;
+        }
+    }
+    shouldRenderFrame() {
+        return (!this.isBuffering &&
+            this.canRenderVideo() &&
+            this.nextFrame !== null &&
+            this.nextFrame.timestamp <= this.getPlaybackTime());
+    }
+    drawCurrentFrame() {
+        if (this.context && this.nextFrame) {
+            this.context.drawImage(this.nextFrame.canvas, 0, 0);
+        }
+        if (this.onVideoFrameCallback && this.canvas) {
+            this.onVideoFrameCallback(this.canvas);
+        }
+        this.nextFrame = null;
+        this.updateNextFrame();
+    }
+    setBufferingState(isBuffering) {
+        if (this.isBuffering !== isBuffering) {
+            this.isBuffering = isBuffering;
+            if (isBuffering) {
+                this.bufferingStartedAtMs = performance.now();
+                this.onBufferingChangeCallback?.(true);
+            }
+            else {
+                this.bufferingStartedAtMs = null;
+                this.onBufferingChangeCallback?.(false);
+            }
+        }
+    }
+    maybeResumeFromBuffering(currentBufferDuration) {
+        if (!this.isCurrentlyBuffering())
+            return;
+        const now = performance.now();
+        const bufferingDuration = now - this.bufferingStartedAtMs;
+        const minTimeElapsed = bufferingDuration >= this.minBufferingTimeoutMs;
+        const bufferHealthy = currentBufferDuration >= this.HEALTHY_BUFER_THRESHOLD_SECONDS;
+        if (minTimeElapsed && bufferHealthy) {
+            Internals.Log.trace({ logLevel: this.logLevel, tag: '@remotion/media' }, `[MediaPlayer] Resuming from buffering after ${bufferingDuration}ms - buffer recovered`);
+            this.setBufferingState(false);
+        }
+    }
+    maybeForceResumeFromBuffering() {
+        if (!this.isCurrentlyBuffering())
+            return;
+        const now = performance.now();
+        const bufferingDuration = now - this.bufferingStartedAtMs;
+        const forceTimeout = bufferingDuration > this.minBufferingTimeoutMs * 10;
+        if (forceTimeout) {
+            Internals.Log.trace({ logLevel: this.logLevel, tag: '@remotion/media' }, `[MediaPlayer] Force resuming from buffering after ${bufferingDuration}ms`);
+            this.setBufferingState(false);
+        }
+    }
+}

package/dist/video/props.d.ts

@@ -1,24 +1,43 @@
 import type { LogLevel, LoopVolumeCurveBehavior, OnVideoFrame, VolumeProp } from 'remotion';
-export type VideoProps = {
+export type FallbackOffthreadVideoProps = {
+    acceptableTimeShiftInSeconds?: number;
+    toneFrequency?: number;
+    transparent?: boolean;
+    toneMapped?: boolean;
+    onError?: (err: Error) => void;
+};
+type MandatoryVideoProps = {
     src: string;
-    className?: string;
-    trimBefore?: number;
-    trimAfter?: number;
-    volume?: VolumeProp;
-    loopVolumeCurveBehavior?: LoopVolumeCurveBehavior;
-    name?: string;
-    pauseWhenBuffering?: boolean;
-    showInTimeline?: boolean;
-    onVideoFrame?: OnVideoFrame;
-    playbackRate?: number;
-    muted?: boolean;
-    delayRenderRetries?: number;
-    delayRenderTimeoutInMilliseconds?: number;
-    style?: React.CSSProperties;
+};
+type OuterVideoProps = {
+    trimBefore: number | undefined;
+    trimAfter: number | undefined;
+};
+type OptionalVideoProps = {
+    className: string | undefined;
+    volume: VolumeProp;
+    loopVolumeCurveBehavior: LoopVolumeCurveBehavior;
+    name: string | undefined;
+    onVideoFrame: OnVideoFrame | undefined;
+    playbackRate: number;
+    muted: boolean;
+    delayRenderRetries: number | null;
+    delayRenderTimeoutInMilliseconds: number | null;
+    style: React.CSSProperties;
     /**
      * @deprecated For internal use only
      */
-    stack?: string;
-    logLevel?: LogLevel;
-    loop?: boolean;
+    stack: string | undefined;
+    logLevel: LogLevel;
+    loop: boolean;
+    audioStreamIndex: number;
+    disallowFallbackToOffthreadVideo: boolean;
+    fallbackOffthreadVideoProps: FallbackOffthreadVideoProps;
+    trimAfter: number | undefined;
+    trimBefore: number | undefined;
+    toneFrequency: number;
+    showInTimeline: boolean;
 };
+export type InnerVideoProps = MandatoryVideoProps & OuterVideoProps & OptionalVideoProps;
+export type VideoProps = MandatoryVideoProps & Partial<OuterVideoProps> & Partial<OptionalVideoProps>;
+export {};

package/dist/video/resolve-playback-time.d.ts

@@ -0,0 +1,8 @@
+export declare const resolvePlaybackTime: ({ absolutePlaybackTimeInSeconds, playbackRate, loop, trimBeforeInSeconds, trimAfterInSeconds, mediaDurationInSeconds, }: {
+    absolutePlaybackTimeInSeconds: number;
+    playbackRate: number;
+    loop: boolean;
+    trimBeforeInSeconds: number | undefined;
+    trimAfterInSeconds: number | undefined;
+    mediaDurationInSeconds: number | undefined;
+}) => number;

package/dist/video/resolve-playback-time.js

@@ -0,0 +1,22 @@
+export const resolvePlaybackTime = ({ absolutePlaybackTimeInSeconds, playbackRate, loop, trimBeforeInSeconds, trimAfterInSeconds, mediaDurationInSeconds, }) => {
+    const loopAfterPreliminary = loop
+        ? Math.min(trimAfterInSeconds ?? Infinity, mediaDurationInSeconds ?? Infinity)
+        : Infinity;
+    const loopAfterConsideringTrimBefore = loopAfterPreliminary - (trimBeforeInSeconds ?? 0);
+    const loopAfterConsideringPlaybackRate = loopAfterConsideringTrimBefore / playbackRate;
+    const timeConsideringLoop = absolutePlaybackTimeInSeconds % loopAfterConsideringPlaybackRate;
+    const time = timeConsideringLoop * playbackRate + (trimBeforeInSeconds ?? 0);
+    if (Number.isNaN(time)) {
+        // eslint-disable-next-line no-console
+        console.log({
+            absolutePlaybackTimeInSeconds,
+            playbackRate,
+            loop,
+            trimBeforeInSeconds,
+            trimAfterInSeconds,
+            mediaDurationInSeconds,
+        });
+        throw new Error('Time is NaN');
+    }
+    return time;
+};

package/dist/video/timeout-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string): Promise<T>;

package/dist/video/timeout-utils.js

@@ -0,0 +1,18 @@
+/* eslint-disable no-promise-executor-return */
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export function withTimeout(promise, timeoutMs, errorMessage = 'Operation timed out') {
+    let timeoutId = null;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = window.setTimeout(() => {
+            reject(new Error(errorMessage));
+        }, timeoutMs);
+    });
+    return Promise.race([
+        promise.finally(() => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }),
+        timeoutPromise,
+    ]);
+}

package/dist/video/video-for-preview.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { LogLevel, LoopVolumeCurveBehavior, OnVideoFrame, VolumeProp } from 'remotion';
+import type { FallbackOffthreadVideoProps } from './props';
+type InnerVideoProps = {
+    readonly className: string | undefined;
+    readonly loop: boolean;
+    readonly src: string;
+    readonly logLevel: LogLevel;
+    readonly muted: boolean;
+    readonly name: string | undefined;
+    readonly volume: VolumeProp;
+    readonly loopVolumeCurveBehavior: LoopVolumeCurveBehavior;
+    readonly onVideoFrame: OnVideoFrame | undefined;
+    readonly playbackRate: number;
+    readonly style: React.CSSProperties;
+    readonly showInTimeline: boolean;
+    readonly trimAfter: number | undefined;
+    readonly trimBefore: number | undefined;
+    readonly stack: string | null;
+    readonly disallowFallbackToOffthreadVideo: boolean;
+    readonly fallbackOffthreadVideoProps: FallbackOffthreadVideoProps;
+    readonly audioStreamIndex: number;
+};
+export declare const VideoForPreview: React.FC<InnerVideoProps>;
+export {};