@remotion/media 4.0.354 → 4.0.356

package/dist/new-video.js

@@ -1,37 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useCallback } from 'react';
-import { Internals, Sequence, useRemotionEnvironment } from 'remotion';
-import { VideoForRendering } from './new-video-for-rendering';
-const { validateMediaTrimProps, resolveTrimProps, validateMediaProps, VideoForPreview, } = Internals;
-export const Video = (props) => {
-    // Should only destruct `startFrom` and `endAt` from props,
-    // rest gets drilled down
-    const { trimBefore, trimAfter, name, pauseWhenBuffering, stack, showInTimeline, ...otherProps } = props;
-    const environment = useRemotionEnvironment();
-    const onDuration = useCallback(() => undefined, []);
-    if (typeof props.src !== 'string') {
-        throw new TypeError(`The \`<Video>\` tag requires a string for \`src\`, but got ${JSON.stringify(props.src)} instead.`);
-    }
-    validateMediaTrimProps({
-        startFrom: undefined,
-        endAt: undefined,
-        trimBefore,
-        trimAfter,
-    });
-    const { trimBeforeValue, trimAfterValue } = resolveTrimProps({
-        startFrom: undefined,
-        endAt: undefined,
-        trimBefore,
-        trimAfter,
-    });
-    if (typeof trimBeforeValue !== 'undefined' ||
-        typeof trimAfterValue !== 'undefined') {
-        return (_jsx(Sequence, { layout: "none", from: 0 - (trimBeforeValue ?? 0), showInTimeline: false, durationInFrames: trimAfterValue, name: name, children: _jsx(Video, { pauseWhenBuffering: pauseWhenBuffering ?? false, ...otherProps }) }));
-    }
-    validateMediaProps(props, 'Video');
-    if (environment.isRendering) {
-        return _jsx(VideoForRendering, { ...otherProps });
-    }
-    const { onAutoPlayError, onVideoFrame, crossOrigin, delayRenderRetries, delayRenderTimeoutInMilliseconds, ...propsForPreview } = otherProps;
-    return (_jsx(VideoForPreview, { _remotionInternalStack: stack ?? null, _remotionInternalNativeLoopPassed: false, onDuration: onDuration, onlyWarnForMediaSeekingError: true, pauseWhenBuffering: pauseWhenBuffering ?? false, showInTimeline: showInTimeline ?? true, onAutoPlayError: onAutoPlayError ?? undefined, onVideoFrame: onVideoFrame ?? null, crossOrigin: crossOrigin, ...propsForPreview }));
-};

package/dist/props.d.ts

@@ -1,29 +0,0 @@
-import type { LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
-import type { LogLevel } from './log';
-export type AudioProps = {
-    src: string;
-    trimBefore?: number;
-    trimAfter?: number;
-    volume?: VolumeProp;
-    loopVolumeCurveBehavior?: LoopVolumeCurveBehavior;
-    name?: string;
-    pauseWhenBuffering?: boolean;
-    showInTimeline?: boolean;
-    onAutoPlayError?: null | (() => void);
-    playbackRate?: number;
-    muted?: boolean;
-    delayRenderRetries?: number;
-    delayRenderTimeoutInMilliseconds?: number;
-    crossOrigin?: '' | 'anonymous' | 'use-credentials';
-    style?: React.CSSProperties;
-    onError?: (err: Error) => void;
-    useWebAudioApi?: boolean;
-    acceptableTimeShiftInSeconds?: number;
-    /**
-     * @deprecated For internal use only
-     */
-    stack?: string;
-    logLevel?: LogLevel;
-    loop?: boolean;
-    _remotionInternalNativeLoopPassed?: boolean;
-};

package/dist/props.js

@@ -1 +0,0 @@
-export {};

package/dist/remember-actual-matroska-timestamps.d.ts

@@ -1,4 +0,0 @@
-export declare const rememberActualMatroskaTimestamps: (isMatroska: boolean) => {
-    observeTimestamp: (startTime: number) => void;
-    getRealTimestamp: (observedTimestamp: number) => number | null;
-};

package/dist/remember-actual-matroska-timestamps.js

@@ -1,19 +0,0 @@
-export const rememberActualMatroskaTimestamps = (isMatroska) => {
-    const observations = [];
-    const observeTimestamp = (startTime) => {
-        if (!isMatroska) {
-            return;
-        }
-        observations.push(startTime);
-    };
-    const getRealTimestamp = (observedTimestamp) => {
-        if (!isMatroska) {
-            return observedTimestamp;
-        }
-        return (observations.find((observation) => Math.abs(observedTimestamp - observation) < 0.001) ?? null);
-    };
-    return {
-        observeTimestamp,
-        getRealTimestamp,
-    };
-};

package/dist/serialize-videoframe.js

@@ -1 +0,0 @@
-"use strict";

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

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { LogLevel } from 'remotion';
-type NewVideoForPreviewProps = {
-    readonly src: string;
-    readonly style?: React.CSSProperties;
-    readonly playbackRate?: number;
-    readonly logLevel?: LogLevel;
-};
-export declare const NewVideoForPreview: React.FC<NewVideoForPreviewProps>;
-export {};

package/dist/video/new-video-for-preview.js

@@ -1,108 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useEffect, useRef, useState } from 'react';
-import { Internals, useBufferState, useCurrentFrame } from 'remotion';
-import { MediaPlayer } from './media-player';
-const { useUnsafeVideoConfig, Timeline, SharedAudioContext } = Internals;
-export const NewVideoForPreview = ({ src, style, playbackRate = 1, logLevel = 'info', }) => {
-    const canvasRef = useRef(null);
-    const videoConfig = useUnsafeVideoConfig();
-    const frame = useCurrentFrame();
-    const mediaPlayerRef = useRef(null);
-    const [mediaPlayerReady, setMediaPlayerReady] = useState(false);
-    const [playing] = Timeline.usePlayingState();
-    const sharedAudioContext = useContext(SharedAudioContext);
-    const buffer = useBufferState();
-    const delayHandleRef = useRef(null);
-    if (!videoConfig) {
-        throw new Error('No video config found');
-    }
-    if (!src) {
-        throw new TypeError('No `src` was passed to <NewVideoForPreview>.');
-    }
-    const actualFps = videoConfig.fps / playbackRate;
-    const currentTime = frame / actualFps;
-    const [initialTimestamp] = useState(currentTime);
-    useEffect(() => {
-        if (!canvasRef.current)
-            return;
-        if (!sharedAudioContext)
-            return;
-        if (!sharedAudioContext.audioContext)
-            return;
-        try {
-            const player = new MediaPlayer({
-                canvas: canvasRef.current,
-                src,
-                logLevel,
-                sharedAudioContext: sharedAudioContext.audioContext,
-            });
-            mediaPlayerRef.current = player;
-            player
-                .initialize(initialTimestamp)
-                .then(() => {
-                setMediaPlayerReady(true);
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[NewVideoForPreview] MediaPlayer initialized successfully`);
-            })
-                .catch((error) => {
-                Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[NewVideoForPreview] Failed to initialize MediaPlayer', error);
-            });
-        }
-        catch (error) {
-            Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[NewVideoForPreview] MediaPlayer initialization failed', error);
-        }
-        return () => {
-            if (delayHandleRef.current) {
-                delayHandleRef.current.unblock();
-                delayHandleRef.current = null;
-            }
-            if (mediaPlayerRef.current) {
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[NewVideoForPreview] Disposing MediaPlayer`);
-                mediaPlayerRef.current.dispose();
-                mediaPlayerRef.current = null;
-            }
-            setMediaPlayerReady(false);
-        };
-    }, [src, logLevel, sharedAudioContext, initialTimestamp]);
-    // sync play/pause state with Remotion timeline (like old VideoForPreview video does)
-    useEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer)
-            return;
-        if (playing) {
-            mediaPlayer.play().catch((error) => {
-                Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[NewVideoForPreview] Failed to play', error);
-            });
-        }
-        else {
-            mediaPlayer.pause();
-        }
-    }, [playing, logLevel, mediaPlayerReady]);
-    // sync target time with MediaPlayer
-    useEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady)
-            return;
-        mediaPlayer.seekTo(currentTime);
-        Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[NewVideoForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
-    }, [currentTime, logLevel, mediaPlayerReady]);
-    // sync MediaPlayer buffering with Remotion buffering
-    useEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady)
-            return;
-        mediaPlayer.onBufferingChange((newBufferingState) => {
-            if (newBufferingState && !delayHandleRef.current) {
-                // Start blocking Remotion playback
-                delayHandleRef.current = buffer.delayPlayback();
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, '[NewVideoForPreview] MediaPlayer buffering - blocking Remotion playback');
-            }
-            else if (!newBufferingState && delayHandleRef.current) {
-                // Unblock Remotion playback
-                delayHandleRef.current.unblock();
-                delayHandleRef.current = null;
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, '[NewVideoForPreview] MediaPlayer unbuffering - unblocking Remotion playback');
-            }
-        });
-    }, [mediaPlayerReady, buffer, logLevel]);
-    return (_jsx("canvas", { ref: canvasRef, width: videoConfig.width, height: videoConfig.height, style: style }));
-};

package/dist/video-extraction/media-player.d.ts

@@ -1,64 +0,0 @@
-import { type LogLevel } from '../log';
-export declare class MediaPlayer {
-    private canvas;
-    private context;
-    private src;
-    private logLevel;
-    private canvasSink;
-    private videoFrameIterator;
-    private nextFrame;
-    private audioSink;
-    private audioBufferIterator;
-    private queuedAudioNodes;
-    private gainNode;
-    private expectedAudioTime;
-    private sharedAudioContext;
-    private mediaTimeOffset;
-    private playing;
-    private animationFrameId;
-    private asyncId;
-    private initialized;
-    private totalDuration;
-    private actualFps;
-    private isStalled;
-    private onStalledChangeCallback?;
-    private lastAudioProgressAtMs;
-    private lastNetworkActivityAtMs;
-    private isNetworkActive;
-    private isSeeking;
-    private canStartAudio;
-    constructor({ canvas, src, logLevel, sharedAudioContext, }: {
-        canvas: HTMLCanvasElement;
-        src: string;
-        logLevel: LogLevel;
-        sharedAudioContext?: AudioContext | null;
-    });
-    initialize(startTime?: number): Promise<void>;
-    seekTo(time: number): void;
-    drawInitialFrame(time?: number): Promise<void>;
-    play(): Promise<void>;
-    pause(): void;
-    dispose(): void;
-    get currentTime(): number;
-    private getPlaybackTime;
-    get duration(): number;
-    get isPlaying(): boolean;
-    get stalled(): boolean;
-    onStalledChange(callback: (isStalled: boolean) => void): void;
-    private renderSingleFrame;
-    private startRenderLoop;
-    private stopRenderLoop;
-    private render;
-    private startVideoIterator;
-    private updateNextFrame;
-    private tryStartAudio;
-    private getCurrentTimeMs;
-    private resetAudioProgressStopwatch;
-    private getAudioLookaheadSec;
-    private calculateAudioStallThresholdSec;
-    private isNetworkStalled;
-    private checkVideoStall;
-    private checkIfStalled;
-    private updateStalledState;
-    private runAudioIterator;
-}