remotion 3.3.51 → 3.3.52

package/dist/video/OffthreadVideoForRendering.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffthreadVideoForRendering = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const absolute_src_1 = require("../absolute-src");
+const use_audio_frame_1 = require("../audio/use-audio-frame");
+const CompositionManager_1 = require("../CompositionManager");
+const default_css_1 = require("../default-css");
+const Img_1 = require("../Img");
+const internals_1 = require("../internals");
+const random_1 = require("../random");
+const Sequence_1 = require("../Sequence");
+const timeline_position_state_1 = require("../timeline-position-state");
+const use_current_frame_1 = require("../use-current-frame");
+const use_unsafe_video_config_1 = require("../use-unsafe-video-config");
+const volume_prop_1 = require("../volume-prop");
+const get_current_time_1 = require("./get-current-time");
+const DEFAULT_IMAGE_FORMAT = 'jpeg';
+const OffthreadVideoForRendering = ({ onError, volume: volumeProp, playbackRate, src, muted, imageFormat, allowAmplificationDuringRender, ...props }) => {
+    const absoluteFrame = (0, timeline_position_state_1.useTimelinePosition)();
+    const frame = (0, use_current_frame_1.useCurrentFrame)();
+    const volumePropsFrame = (0, use_audio_frame_1.useFrameForVolumeProp)();
+    const videoConfig = (0, use_unsafe_video_config_1.useUnsafeVideoConfig)();
+    const sequenceContext = (0, react_1.useContext)(Sequence_1.SequenceContext);
+    const mediaStartsAt = (0, use_audio_frame_1.useMediaStartsAt)();
+    const { registerAsset, unregisterAsset } = (0, react_1.useContext)(CompositionManager_1.CompositionManager);
+    if (!src) {
+        throw new TypeError('No `src` was passed to <OffthreadVideo>.');
+    }
+    // Generate a string that's as unique as possible for this asset
+    // but at the same time the same on all threads
+    const id = (0, react_1.useMemo)(() => `offthreadvideo-${(0, random_1.random)(src !== null && src !== void 0 ? src : '')}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames}`, [
+        src,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames,
+    ]);
+    if (!videoConfig) {
+        throw new Error('No video config found');
+    }
+    const volume = (0, volume_prop_1.evaluateVolume)({
+        volume: volumeProp,
+        frame: volumePropsFrame,
+        mediaVolume: 1,
+        allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+    });
+    (0, react_1.useEffect)(() => {
+        if (!src) {
+            throw new Error('No src passed');
+        }
+        if (!window.remotion_videoEnabled) {
+            return;
+        }
+        if (muted) {
+            return;
+        }
+        if (volume <= 0) {
+            return;
+        }
+        registerAsset({
+            type: 'video',
+            src: (0, absolute_src_1.getAbsoluteSrc)(src),
+            id,
+            frame: absoluteFrame,
+            volume,
+            mediaFrame: frame,
+            playbackRate: playbackRate !== null && playbackRate !== void 0 ? playbackRate : 1,
+            allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+        });
+        return () => unregisterAsset(id);
+    }, [
+        muted,
+        src,
+        registerAsset,
+        id,
+        unregisterAsset,
+        volume,
+        frame,
+        absoluteFrame,
+        playbackRate,
+        allowAmplificationDuringRender,
+    ]);
+    const currentTime = (0, react_1.useMemo)(() => {
+        return ((0, get_current_time_1.getExpectedMediaFrameUncorrected)({
+            frame,
+            playbackRate: playbackRate || 1,
+            startFrom: -mediaStartsAt,
+        }) / videoConfig.fps);
+    }, [frame, mediaStartsAt, playbackRate, videoConfig.fps]);
+    const actualSrc = (0, react_1.useMemo)(() => {
+        return `http://localhost:${window.remotion_proxyPort}/proxy?src=${encodeURIComponent((0, absolute_src_1.getAbsoluteSrc)(src))}&time=${encodeURIComponent(currentTime)}&imageFormat=${imageFormat !== null && imageFormat !== void 0 ? imageFormat : DEFAULT_IMAGE_FORMAT}`;
+    }, [currentTime, imageFormat, src]);
+    const onErr = (0, react_1.useCallback)((e) => {
+        onError === null || onError === void 0 ? void 0 : onError(e);
+    }, [onError]);
+    const className = (0, react_1.useMemo)(() => {
+        return [default_css_1.OFFTHREAD_VIDEO_CLASS_NAME, props.className]
+            .filter(internals_1.Internals.truthy)
+            .join(' ');
+    }, [props.className]);
+    return ((0, jsx_runtime_1.jsx)(Img_1.Img, { src: actualSrc, className: className, ...props, onError: onErr }));
+};
+exports.OffthreadVideoForRendering = OffthreadVideoForRendering;

package/dist/video/Video.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { RemotionMainVideoProps } from './props';
+export declare const Video: (props: Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, "nonce" | "autoPlay" | "controls" | "onEnded"> & {
+    volume?: import("../volume-prop").VolumeProp | undefined;
+    playbackRate?: number | undefined;
+    acceptableTimeShiftInSeconds?: number | undefined;
+    allowAmplificationDuringRender?: boolean | undefined;
+} & RemotionMainVideoProps & React.RefAttributes<HTMLVideoElement | null>) => React.ReactElement | null;

package/dist/video/Video.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Video = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const get_environment_1 = require("../get-environment");
+const loop_1 = require("../loop");
+const Sequence_1 = require("../Sequence");
+const use_video_config_1 = require("../use-video-config");
+const validate_media_props_1 = require("../validate-media-props");
+const validate_start_from_props_1 = require("../validate-start-from-props");
+const duration_state_1 = require("./duration-state");
+const VideoForDevelopment_1 = require("./VideoForDevelopment");
+const VideoForRendering_1 = require("./VideoForRendering");
+const VideoForwardingFunction = (props, ref) => {
+    var _a;
+    const { startFrom, endAt, ...otherProps } = props;
+    const { loop, ...propsOtherThanLoop } = props;
+    const { fps } = (0, use_video_config_1.useVideoConfig)();
+    const environment = (0, get_environment_1.useRemotionEnvironment)();
+    const { durations, setDurations } = (0, react_1.useContext)(duration_state_1.DurationsContext);
+    if (typeof ref === 'string') {
+        throw new Error('string refs are not supported');
+    }
+    if (typeof props.src !== 'string') {
+        throw new TypeError(`The \`<Video>\` tag requires a string for \`src\`, but got ${JSON.stringify(props.src)} instead.`);
+    }
+    const onDuration = (0, react_1.useCallback)((src, durationInSeconds) => {
+        setDurations({ type: 'got-duration', durationInSeconds, src });
+    }, [setDurations]);
+    if (loop && props.src && durations[props.src] !== undefined) {
+        const naturalDuration = durations[props.src] * fps;
+        const playbackRate = (_a = props.playbackRate) !== null && _a !== void 0 ? _a : 1;
+        const durationInFrames = Math.floor(naturalDuration / playbackRate);
+        return ((0, jsx_runtime_1.jsx)(loop_1.Loop, { durationInFrames: durationInFrames, children: (0, jsx_runtime_1.jsx)(exports.Video, { ...propsOtherThanLoop, ref: ref }) }));
+    }
+    if (typeof startFrom !== 'undefined' || typeof endAt !== 'undefined') {
+        (0, validate_start_from_props_1.validateStartFromProps)(startFrom, endAt);
+        const startFromFrameNo = startFrom !== null && startFrom !== void 0 ? startFrom : 0;
+        const endAtFrameNo = endAt !== null && endAt !== void 0 ? endAt : Infinity;
+        return ((0, jsx_runtime_1.jsx)(Sequence_1.Sequence, { layout: "none", from: 0 - startFromFrameNo, showInTimeline: false, durationInFrames: endAtFrameNo, children: (0, jsx_runtime_1.jsx)(exports.Video, { ...otherProps, ref: ref }) }));
+    }
+    (0, validate_media_props_1.validateMediaProps)(props, 'Video');
+    if (environment === 'rendering') {
+        return ((0, jsx_runtime_1.jsx)(VideoForRendering_1.VideoForRendering, { onDuration: onDuration, ...otherProps, ref: ref }));
+    }
+    return ((0, jsx_runtime_1.jsx)(VideoForDevelopment_1.VideoForDevelopment, { onlyWarnForMediaSeekingError: false, ...otherProps, ref: ref, onDuration: onDuration }));
+};
+const forward = react_1.forwardRef;
+exports.Video = forward(VideoForwardingFunction);

package/dist/video/VideoForDevelopment.d.ts

@@ -0,0 +1,11 @@
+import type { ForwardRefExoticComponent, RefAttributes } from 'react';
+import React from 'react';
+export declare const VideoForDevelopment: ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, "nonce" | "autoPlay" | "controls" | "onEnded"> & {
+    volume?: import("../volume-prop").VolumeProp | undefined;
+    playbackRate?: number | undefined;
+    acceptableTimeShiftInSeconds?: number | undefined;
+    allowAmplificationDuringRender?: boolean | undefined;
+} & {
+    onlyWarnForMediaSeekingError: boolean;
+    onDuration: (src: string, durationInSeconds: number) => void;
+} & RefAttributes<HTMLVideoElement>>;

package/dist/video/VideoForDevelopment.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoForDevelopment = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const use_audio_frame_1 = require("../audio/use-audio-frame");
+const prefetch_1 = require("../prefetch");
+const Sequence_1 = require("../Sequence");
+const use_media_in_timeline_1 = require("../use-media-in-timeline");
+const use_media_playback_1 = require("../use-media-playback");
+const use_media_tag_volume_1 = require("../use-media-tag-volume");
+const use_sync_volume_with_media_tag_1 = require("../use-sync-volume-with-media-tag");
+const use_video_config_1 = require("../use-video-config");
+const volume_position_state_1 = require("../volume-position-state");
+const video_fragment_1 = require("./video-fragment");
+const VideoForDevelopmentRefForwardingFunction = (props, ref) => {
+    var _a, _b;
+    const videoRef = (0, react_1.useRef)(null);
+    const volumePropFrame = (0, use_audio_frame_1.useFrameForVolumeProp)();
+    const { fps, durationInFrames } = (0, use_video_config_1.useVideoConfig)();
+    const parentSequence = (0, react_1.useContext)(Sequence_1.SequenceContext);
+    const { volume, muted, playbackRate, onlyWarnForMediaSeekingError, src, onDuration, 
+    // @ts-expect-error
+    acceptableTimeShift, acceptableTimeShiftInSeconds, ...nativeProps } = props;
+    if (typeof acceptableTimeShift !== 'undefined') {
+        throw new Error('acceptableTimeShift has been removed. Use acceptableTimeShiftInSeconds instead.');
+    }
+    const actualVolume = (0, use_media_tag_volume_1.useMediaTagVolume)(videoRef);
+    const [mediaVolume] = (0, volume_position_state_1.useMediaVolumeState)();
+    const [mediaMuted] = (0, volume_position_state_1.useMediaMutedState)();
+    (0, use_media_in_timeline_1.useMediaInTimeline)({
+        mediaRef: videoRef,
+        volume,
+        mediaVolume,
+        mediaType: 'video',
+        src,
+        playbackRate: (_a = props.playbackRate) !== null && _a !== void 0 ? _a : 1,
+    });
+    (0, use_sync_volume_with_media_tag_1.useSyncVolumeWithMediaTag)({
+        volumePropFrame,
+        actualVolume,
+        volume,
+        mediaVolume,
+        mediaRef: videoRef,
+    });
+    (0, use_media_playback_1.useMediaPlayback)({
+        mediaRef: videoRef,
+        src,
+        mediaType: 'video',
+        playbackRate: (_b = props.playbackRate) !== null && _b !== void 0 ? _b : 1,
+        onlyWarnForMediaSeekingError,
+        acceptableTimeshift: acceptableTimeShiftInSeconds !== null && acceptableTimeShiftInSeconds !== void 0 ? acceptableTimeShiftInSeconds : use_media_playback_1.DEFAULT_ACCEPTABLE_TIMESHIFT,
+    });
+    const actualFrom = parentSequence
+        ? parentSequence.relativeFrom + parentSequence.cumulatedFrom
+        : 0;
+    const duration = parentSequence
+        ? Math.min(parentSequence.durationInFrames, durationInFrames)
+        : durationInFrames;
+    const actualSrc = (0, video_fragment_1.useAppendVideoFragment)({
+        actualSrc: (0, prefetch_1.usePreload)(src),
+        actualFrom,
+        duration,
+        fps,
+    });
+    (0, react_1.useImperativeHandle)(ref, () => {
+        return videoRef.current;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        const errorHandler = () => {
+            var _a;
+            if (current === null || current === void 0 ? void 0 : current.error) {
+                console.error('Error occurred in video', current === null || current === void 0 ? void 0 : current.error);
+                throw new Error(`The browser threw an error while playing the video ${src}: Code ${current.error.code} - ${(_a = current === null || current === void 0 ? void 0 : current.error) === null || _a === void 0 ? void 0 : _a.message}. See https://remotion.dev/docs/media-playback-error for help`);
+            }
+            else {
+                throw new Error('The browser threw an error');
+            }
+        };
+        current.addEventListener('error', errorHandler, { once: true });
+        return () => {
+            current.removeEventListener('error', errorHandler);
+        };
+    }, [src]);
+    const currentOnDurationCallback = (0, react_1.useRef)();
+    currentOnDurationCallback.current = onDuration;
+    (0, react_1.useEffect)(() => {
+        var _a;
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        if (current.duration) {
+            (_a = currentOnDurationCallback.current) === null || _a === void 0 ? void 0 : _a.call(currentOnDurationCallback, src, current.duration);
+            return;
+        }
+        const onLoadedMetadata = () => {
+            var _a;
+            (_a = currentOnDurationCallback.current) === null || _a === void 0 ? void 0 : _a.call(currentOnDurationCallback, src, current.duration);
+        };
+        current.addEventListener('loadedmetadata', onLoadedMetadata);
+        return () => {
+            current.removeEventListener('loadedmetadata', onLoadedMetadata);
+        };
+    }, [src]);
+    return ((0, jsx_runtime_1.jsx)("video", { ref: videoRef, muted: muted || mediaMuted, playsInline: true, src: actualSrc, ...nativeProps }));
+};
+// Copy types from forwardRef but not necessary to remove ref
+exports.VideoForDevelopment = (0, react_1.forwardRef)(VideoForDevelopmentRefForwardingFunction);

package/dist/video/VideoForRendering.d.ts

@@ -0,0 +1,10 @@
+import type { ForwardRefExoticComponent, RefAttributes } from 'react';
+import React from 'react';
+export declare const VideoForRendering: ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, "nonce" | "autoPlay" | "controls" | "onEnded"> & {
+    volume?: import("../volume-prop").VolumeProp | undefined;
+    playbackRate?: number | undefined;
+    acceptableTimeShiftInSeconds?: number | undefined;
+    allowAmplificationDuringRender?: boolean | undefined;
+} & {
+    onDuration: (src: string, durationInSeconds: number) => void;
+} & RefAttributes<HTMLVideoElement>>;

package/dist/video/VideoForRendering.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoForRendering = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const absolute_src_1 = require("../absolute-src");
+const use_audio_frame_1 = require("../audio/use-audio-frame");
+const CompositionManager_1 = require("../CompositionManager");
+const delay_render_1 = require("../delay-render");
+const get_environment_1 = require("../get-environment");
+const is_approximately_the_same_1 = require("../is-approximately-the-same");
+const random_1 = require("../random");
+const Sequence_1 = require("../Sequence");
+const timeline_position_state_1 = require("../timeline-position-state");
+const use_current_frame_1 = require("../use-current-frame");
+const use_unsafe_video_config_1 = require("../use-unsafe-video-config");
+const volume_prop_1 = require("../volume-prop");
+const warn_about_non_seekable_media_1 = require("../warn-about-non-seekable-media");
+const get_current_time_1 = require("./get-current-time");
+const VideoForRenderingForwardFunction = ({ onError, volume: volumeProp, allowAmplificationDuringRender, playbackRate, onDuration, ...props }, ref) => {
+    const absoluteFrame = (0, timeline_position_state_1.useTimelinePosition)();
+    const frame = (0, use_current_frame_1.useCurrentFrame)();
+    const volumePropsFrame = (0, use_audio_frame_1.useFrameForVolumeProp)();
+    const videoConfig = (0, use_unsafe_video_config_1.useUnsafeVideoConfig)();
+    const videoRef = (0, react_1.useRef)(null);
+    const sequenceContext = (0, react_1.useContext)(Sequence_1.SequenceContext);
+    const mediaStartsAt = (0, use_audio_frame_1.useMediaStartsAt)();
+    const environment = (0, get_environment_1.useRemotionEnvironment)();
+    const { registerAsset, unregisterAsset } = (0, react_1.useContext)(CompositionManager_1.CompositionManager);
+    // Generate a string that's as unique as possible for this asset
+    // but at the same time the same on all threads
+    const id = (0, react_1.useMemo)(() => {
+        var _a;
+        return `video-${(0, random_1.random)((_a = props.src) !== null && _a !== void 0 ? _a : '')}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames}`;
+    }, [
+        props.src,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames,
+    ]);
+    if (!videoConfig) {
+        throw new Error('No video config found');
+    }
+    const volume = (0, volume_prop_1.evaluateVolume)({
+        volume: volumeProp,
+        frame: volumePropsFrame,
+        mediaVolume: 1,
+        allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+    });
+    (0, react_1.useEffect)(() => {
+        if (!props.src) {
+            throw new Error('No src passed');
+        }
+        if (props.muted) {
+            return;
+        }
+        if (volume <= 0) {
+            return;
+        }
+        if (!window.remotion_audioEnabled) {
+            return;
+        }
+        registerAsset({
+            type: 'video',
+            src: (0, absolute_src_1.getAbsoluteSrc)(props.src),
+            id,
+            frame: absoluteFrame,
+            volume,
+            mediaFrame: frame,
+            playbackRate: playbackRate !== null && playbackRate !== void 0 ? playbackRate : 1,
+            allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+        });
+        return () => unregisterAsset(id);
+    }, [
+        props.muted,
+        props.src,
+        registerAsset,
+        id,
+        unregisterAsset,
+        volume,
+        frame,
+        absoluteFrame,
+        playbackRate,
+        allowAmplificationDuringRender,
+    ]);
+    (0, react_1.useImperativeHandle)(ref, () => {
+        return videoRef.current;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!window.remotion_videoEnabled) {
+            return;
+        }
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        const currentTime = (() => {
+            return (0, get_current_time_1.getMediaTime)({
+                fps: videoConfig.fps,
+                frame,
+                src: props.src,
+                playbackRate: playbackRate || 1,
+                startFrom: -mediaStartsAt,
+                mediaType: 'video',
+            });
+        })();
+        const handle = (0, delay_render_1.delayRender)(`Rendering <Video /> with src="${props.src}"`);
+        if (process.env.NODE_ENV === 'test') {
+            (0, delay_render_1.continueRender)(handle);
+            return;
+        }
+        if ((0, is_approximately_the_same_1.isApproximatelyTheSame)(current.currentTime, currentTime)) {
+            if (current.readyState >= 2) {
+                (0, delay_render_1.continueRender)(handle);
+                return;
+            }
+            const loadedDataHandler = () => {
+                (0, delay_render_1.continueRender)(handle);
+            };
+            current.addEventListener('loadeddata', loadedDataHandler, { once: true });
+            return () => {
+                current.removeEventListener('loadeddata', loadedDataHandler);
+            };
+        }
+        current.currentTime = currentTime;
+        const seekedHandler = () => {
+            (0, warn_about_non_seekable_media_1.warnAboutNonSeekableMedia)(current, 'exception');
+            if (window.navigator.platform.startsWith('Mac')) {
+                // Improve me: This is ensures frame perfectness but slows down render.
+                // Please see this issue for context: https://github.com/remotion-dev/remotion/issues/200
+                // Only affects macOS since it uses VideoToolbox decoding.
+                setTimeout(() => {
+                    (0, delay_render_1.continueRender)(handle);
+                }, 100);
+            }
+            else {
+                (0, delay_render_1.continueRender)(handle);
+            }
+        };
+        current.addEventListener('seeked', seekedHandler, { once: true });
+        const endedHandler = () => {
+            (0, delay_render_1.continueRender)(handle);
+        };
+        current.addEventListener('ended', endedHandler, { once: true });
+        const errorHandler = () => {
+            var _a;
+            if (current === null || current === void 0 ? void 0 : current.error) {
+                console.error('Error occurred in video', current === null || current === void 0 ? void 0 : current.error);
+                throw new Error(`The browser threw an error while playing the video ${props.src}: Code ${current.error.code} - ${(_a = current === null || current === void 0 ? void 0 : current.error) === null || _a === void 0 ? void 0 : _a.message}. See https://remotion.dev/docs/media-playback-error for help`);
+            }
+            else {
+                throw new Error('The browser threw an error');
+            }
+        };
+        current.addEventListener('error', errorHandler, { once: true });
+        // If video skips to another frame or unmounts, we clear the created handle
+        return () => {
+            current.removeEventListener('ended', endedHandler);
+            current.removeEventListener('error', errorHandler);
+            current.removeEventListener('seeked', seekedHandler);
+            (0, delay_render_1.continueRender)(handle);
+        };
+    }, [
+        volumePropsFrame,
+        props.src,
+        playbackRate,
+        videoConfig.fps,
+        frame,
+        mediaStartsAt,
+    ]);
+    const { src } = props;
+    // If video source switches, make new handle
+    if (environment === 'rendering') {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        (0, react_1.useLayoutEffect)(() => {
+            if (process.env.NODE_ENV === 'test') {
+                return;
+            }
+            const newHandle = (0, delay_render_1.delayRender)('Loading <Video> duration with src=' + src);
+            const { current } = videoRef;
+            const didLoad = () => {
+                if (current === null || current === void 0 ? void 0 : current.duration) {
+                    onDuration(src, current.duration);
+                }
+                (0, delay_render_1.continueRender)(newHandle);
+            };
+            if (current === null || current === void 0 ? void 0 : current.duration) {
+                onDuration(src, current.duration);
+                (0, delay_render_1.continueRender)(newHandle);
+            }
+            else {
+                current === null || current === void 0 ? void 0 : current.addEventListener('loadedmetadata', didLoad, { once: true });
+            }
+            // If tag gets unmounted, clear pending handles because video metadata is not going to load
+            return () => {
+                current === null || current === void 0 ? void 0 : current.removeEventListener('loadedmetadata', didLoad);
+                (0, delay_render_1.continueRender)(newHandle);
+            };
+        }, [src, onDuration]);
+    }
+    return (0, jsx_runtime_1.jsx)("video", { ref: videoRef, ...props, onError: onError });
+};
+exports.VideoForRendering = (0, react_1.forwardRef)(VideoForRenderingForwardFunction);

package/dist/video/duration-state.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+declare type DurationState = Record<string, number>;
+declare type DurationAction = {
+    type: 'got-duration';
+    src: string;
+    durationInSeconds: number;
+};
+export declare const durationReducer: (state: DurationState, action: DurationAction) => DurationState;
+declare type TDurationsContext = {
+    durations: DurationState;
+    setDurations: React.Dispatch<DurationAction>;
+};
+export declare const DurationsContext: React.Context<TDurationsContext>;
+export declare const DurationsContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/video/duration-state.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurationsContextProvider = exports.DurationsContext = exports.durationReducer = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const durationReducer = (state, action) => {
+    switch (action.type) {
+        case 'got-duration':
+            return {
+                ...state,
+                [action.src]: action.durationInSeconds,
+            };
+        default:
+            return state;
+    }
+};
+exports.durationReducer = durationReducer;
+exports.DurationsContext = (0, react_1.createContext)({
+    durations: {},
+    setDurations: () => {
+        throw new Error('context missing');
+    },
+});
+const DurationsContextProvider = ({ children }) => {
+    const [durations, setDurations] = (0, react_1.useReducer)(exports.durationReducer, {});
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            durations,
+            setDurations,
+        };
+    }, [durations]);
+    return ((0, jsx_runtime_1.jsx)(exports.DurationsContext.Provider, { value: value, children: children }));
+};
+exports.DurationsContextProvider = DurationsContextProvider;

package/dist/video/get-current-time.d.ts

@@ -0,0 +1,13 @@
+export declare const getExpectedMediaFrameUncorrected: ({ frame, playbackRate, startFrom, }: {
+    frame: number;
+    playbackRate: number;
+    startFrom: number;
+}) => number;
+export declare const getMediaTime: ({ fps, frame, src, playbackRate, startFrom, mediaType, }: {
+    fps: number;
+    frame: number;
+    src: string;
+    playbackRate: number;
+    startFrom: number;
+    mediaType: 'video' | 'audio';
+}) => number;

package/dist/video/get-current-time.js

@@ -0,0 +1,31 @@
+"use strict";
+// Calculate the `.currentTime` of a video or audio element
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMediaTime = exports.getExpectedMediaFrameUncorrected = void 0;
+const interpolate_1 = require("../interpolate");
+const getExpectedMediaFrameUncorrected = ({ frame, playbackRate, startFrom, }) => {
+    return (0, interpolate_1.interpolate)(frame, [-1, startFrom, startFrom + 1], [-1, startFrom, startFrom + playbackRate]);
+};
+exports.getExpectedMediaFrameUncorrected = getExpectedMediaFrameUncorrected;
+const getMediaTime = ({ fps, frame, src, playbackRate, startFrom, mediaType, }) => {
+    const expectedFrame = (0, exports.getExpectedMediaFrameUncorrected)({
+        frame,
+        playbackRate,
+        startFrom,
+    });
+    if (src.endsWith('webm')) {
+        // For WebM videos, we need to add a little bit of shift to get the right frame.
+        const msPerFrame = 1000 / fps;
+        const msShift = msPerFrame / 2;
+        return (expectedFrame * msPerFrame + msShift) / 1000;
+    }
+    if (mediaType === 'video') {
+        // In Chrome, for MP4s, if 30fps, the first frame is still displayed at 0.033333
+        // even though after that it increases by 0.033333333 each.
+        // So frame = 0 in Remotion is like frame = 1 for the browser
+        return (expectedFrame + 1) / fps;
+    }
+    // For audio, we don't do any shift correction
+    return expectedFrame / fps;
+};
+exports.getMediaTime = getMediaTime;

package/dist/video/index.d.ts

@@ -0,0 +1,3 @@
+export { OffthreadVideo } from './OffthreadVideo';
+export { OffthreadVideoImageFormat, OffthreadVideoProps as RemotionOffthreadVideoProps, RemotionMainVideoProps, RemotionVideoProps, } from './props';
+export { Video } from './Video';

package/dist/video/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Video = exports.OffthreadVideo = void 0;
+var OffthreadVideo_1 = require("./OffthreadVideo");
+Object.defineProperty(exports, "OffthreadVideo", { enumerable: true, get: function () { return OffthreadVideo_1.OffthreadVideo; } });
+var Video_1 = require("./Video");
+Object.defineProperty(exports, "Video", { enumerable: true, get: function () { return Video_1.Video; } });

package/dist/video/props.d.ts

@@ -0,0 +1,25 @@
+import type React from 'react';
+import type { VolumeProp } from '../volume-prop';
+export declare type RemotionMainVideoProps = {
+    startFrom?: number;
+    endAt?: number;
+};
+export declare type RemotionVideoProps = Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, 'autoPlay' | 'controls' | 'onEnded' | 'nonce'> & {
+    volume?: VolumeProp;
+    playbackRate?: number;
+    acceptableTimeShiftInSeconds?: number;
+    allowAmplificationDuringRender?: boolean;
+};
+export declare type OffthreadVideoImageFormat = 'png' | 'jpeg';
+export declare type OffthreadVideoProps = {
+    src: string;
+    className?: string;
+    style?: React.CSSProperties;
+    volume?: VolumeProp;
+    playbackRate?: number;
+    muted?: boolean;
+    onError?: React.ReactEventHandler<HTMLVideoElement | HTMLImageElement>;
+    imageFormat?: OffthreadVideoImageFormat;
+    acceptableTimeShiftInSeconds?: number;
+    allowAmplificationDuringRender?: boolean;
+};

package/dist/video/props.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });