remotion 4.0.0-lambda.3 → 4.0.0-newpaths.13

package/dist/audio/AudioForRendering.js

@@ -5,41 +5,52 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const absolute_src_1 = require("../absolute-src");
 const CompositionManager_1 = require("../CompositionManager");
+const delay_render_1 = require("../delay-render");
+const get_environment_1 = require("../get-environment");
 const random_1 = require("../random");
-const sequencing_1 = require("../sequencing");
-const use_frame_1 = require("../use-frame");
+const Sequence_1 = require("../Sequence");
+const timeline_position_state_1 = require("../timeline-position-state");
+const use_current_frame_1 = require("../use-current-frame");
 const volume_prop_1 = require("../volume-prop");
 const use_audio_frame_1 = require("./use-audio-frame");
 const AudioForRenderingRefForwardingFunction = (props, ref) => {
     const audioRef = (0, react_1.useRef)(null);
-    const absoluteFrame = (0, use_frame_1.useAbsoluteCurrentFrame)();
+    const absoluteFrame = (0, timeline_position_state_1.useTimelinePosition)();
     const volumePropFrame = (0, use_audio_frame_1.useFrameForVolumeProp)();
-    const frame = (0, use_frame_1.useCurrentFrame)();
-    const sequenceContext = (0, react_1.useContext)(sequencing_1.SequenceContext);
+    const frame = (0, use_current_frame_1.useCurrentFrame)();
+    const sequenceContext = (0, react_1.useContext)(Sequence_1.SequenceContext);
     const { registerAsset, unregisterAsset } = (0, react_1.useContext)(CompositionManager_1.CompositionManager);
+    const environment = (0, get_environment_1.useRemotionEnvironment)();
     // 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 `audio-${(0, random_1.random)((_a = props.src) !== null && _a !== void 0 ? _a : '')}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames}-muted:${props.muted}`;
-    }, [props.muted, props.src, sequenceContext]);
-    const { volume: volumeProp, playbackRate, ...nativeProps } = props;
+        return `audio-${(0, random_1.random)((_a = props.src) !== null && _a !== void 0 ? _a : '')}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames}`;
+    }, [props.src, sequenceContext]);
+    const { volume: volumeProp, playbackRate, allowAmplificationDuringRender, ...nativeProps } = props;
     const volume = (0, volume_prop_1.evaluateVolume)({
         volume: volumeProp,
         frame: volumePropFrame,
         mediaVolume: 1,
+        allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
     });
     (0, react_1.useImperativeHandle)(ref, () => {
         return audioRef.current;
-    });
+    }, []);
     (0, react_1.useEffect)(() => {
         var _a;
         if (!props.src) {
             throw new Error('No src passed');
         }
+        if (!window.remotion_audioEnabled) {
+            return;
+        }
         if (props.muted) {
             return;
         }
+        if (volume <= 0) {
+            return;
+        }
         registerAsset({
             type: 'audio',
             src: (0, absolute_src_1.getAbsoluteSrc)(props.src),
@@ -48,6 +59,7 @@ const AudioForRenderingRefForwardingFunction = (props, ref) => {
             volume,
             mediaFrame: frame,
             playbackRate: (_a = props.playbackRate) !== null && _a !== void 0 ? _a : 1,
+            allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
         });
         return () => unregisterAsset(id);
     }, [
@@ -62,7 +74,38 @@ const AudioForRenderingRefForwardingFunction = (props, ref) => {
         frame,
         playbackRate,
         props.playbackRate,
+        allowAmplificationDuringRender,
     ]);
+    const { src, onDuration } = props;
+    // If audio 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 <Audio> duration with src=' + src);
+            const { current } = audioRef;
+            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)("audio", { ref: audioRef, ...nativeProps });
 };
 exports.AudioForRendering = (0, react_1.forwardRef)(AudioForRenderingRefForwardingFunction);

package/dist/audio/props.d.ts

@@ -1,10 +1,12 @@
 /// <reference types="react" />
-import { VolumeProp } from '../volume-prop';
+import type { VolumeProp } from '../volume-prop';
 export declare type RemotionMainAudioProps = {
     startFrom?: number;
     endAt?: number;
 };
-export declare type RemotionAudioProps = Omit<React.DetailedHTMLProps<React.AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>, 'autoPlay' | 'controls' | 'loop' | 'onEnded'> & {
+export declare type RemotionAudioProps = Omit<React.DetailedHTMLProps<React.AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>, 'autoPlay' | 'controls' | 'onEnded' | 'nonce' | 'onResize' | 'onResizeCapture'> & {
     volume?: VolumeProp;
     playbackRate?: number;
+    acceptableTimeShiftInSeconds?: number;
+    allowAmplificationDuringRender?: boolean;
 };

package/dist/audio/shared-audio-tags.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { RemotionAudioProps } from './props';
+import type { RemotionAudioProps } from './props';
 /**
  * This functionality of Remotion will keep a certain amount
  * of <audio> tags pre-mounted and by default filled with an empty audio track.
@@ -15,11 +15,16 @@ declare type AudioElem = {
     id: number;
     props: RemotionAudioProps;
     el: React.RefObject<HTMLAudioElement>;
+    audioId: string;
 };
 declare type SharedContext = {
-    registerAudio: (aud: RemotionAudioProps) => AudioElem;
+    registerAudio: (aud: RemotionAudioProps, audioId: string) => AudioElem;
     unregisterAudio: (id: number) => void;
-    updateAudio: (id: number, aud: RemotionAudioProps) => void;
+    updateAudio: (options: {
+        id: number;
+        aud: RemotionAudioProps;
+        audioId: string;
+    }) => void;
     playAllAudios: () => void;
     numberOfAudioTags: number;
 };
@@ -28,5 +33,5 @@ export declare const SharedAudioContextProvider: React.FC<{
     numberOfAudioTags: number;
     children: React.ReactNode;
 }>;
-export declare const useSharedAudio: (aud: RemotionAudioProps) => AudioElem;
+export declare const useSharedAudio: (aud: RemotionAudioProps, audioId: string) => AudioElem;
 export {};

package/dist/audio/shared-audio-tags.js

@@ -27,9 +27,40 @@ exports.useSharedAudio = exports.SharedAudioContextProvider = exports.SharedAudi
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = __importStar(require("react"));
 const EMPTY_AUDIO = 'data:audio/mp3;base64,/+MYxAAJcAV8AAgAABn//////+/gQ5BAMA+D4Pg+BAQBAEAwD4Pg+D4EBAEAQDAPg++hYBH///hUFQVBUFREDQNHmf///////+MYxBUGkAGIMAAAAP/29Xt6lUxBTUUzLjEwMFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV/+MYxDUAAANIAAAAAFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV';
+const compareProps = (obj1, obj2) => {
+    const keysA = Object.keys(obj1).sort();
+    const keysB = Object.keys(obj2).sort();
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (let i = 0; i < keysA.length; i++) {
+        // Not the same keys
+        if (keysA[i] !== keysB[i]) {
+            return false;
+        }
+        // Not the same values
+        if (obj1[keysA[i]] !== obj2[keysB[i]]) {
+            return false;
+        }
+    }
+    return true;
+};
+const didPropChange = (key, newProp, prevProp) => {
+    // /music.mp3 and http://localhost:3000/music.mp3 are the same
+    if (key === 'src' &&
+        !prevProp.startsWith('data:') &&
+        !newProp.startsWith('data:')) {
+        return (new URL(prevProp, window.location.origin).toString() !==
+            new URL(newProp, window.location.origin).toString());
+    }
+    if (prevProp === newProp) {
+        return false;
+    }
+    return true;
+};
 exports.SharedAudioContext = (0, react_1.createContext)(null);
 const SharedAudioContextProvider = ({ children, numberOfAudioTags }) => {
-    const [audios, setAudios] = (0, react_1.useState)([]);
+    const audios = (0, react_1.useRef)([]);
     const [initialNumberOfAudioTags] = (0, react_1.useState)(numberOfAudioTags);
     if (numberOfAudioTags !== initialNumberOfAudioTags) {
         throw new Error('The number of shared audio tags has changed dynamically. Once you have set this property, you cannot change it afterwards.');
@@ -40,7 +71,38 @@ const SharedAudioContextProvider = ({ children, numberOfAudioTags }) => {
         });
     }, [numberOfAudioTags]);
     const takenAudios = (0, react_1.useRef)(new Array(numberOfAudioTags).fill(false));
-    const registerAudio = (0, react_1.useCallback)((aud) => {
+    const rerenderAudios = (0, react_1.useCallback)(() => {
+        refs.forEach(({ ref, id }) => {
+            var _a;
+            const data = (_a = audios.current) === null || _a === void 0 ? void 0 : _a.find((a) => a.id === id);
+            const { current } = ref;
+            if (!current) {
+                // Whole player has been unmounted, the refs don't exist anymore.
+                // It is not an error anymore though
+                return;
+            }
+            if (data === undefined) {
+                current.src = EMPTY_AUDIO;
+                return;
+            }
+            if (!data) {
+                throw new TypeError('Expected audio data to be there');
+            }
+            Object.keys(data.props).forEach((key) => {
+                // @ts-expect-error
+                if (didPropChange(key, data.props[key], current[key])) {
+                    // @ts-expect-error
+                    current[key] = data.props[key];
+                }
+            });
+        });
+    }, [refs]);
+    const registerAudio = (0, react_1.useCallback)((aud, audioId) => {
+        var _a, _b;
+        const found = (_a = audios.current) === null || _a === void 0 ? void 0 : _a.find((a) => a.audioId === audioId);
+        if (found) {
+            return found;
+        }
         const firstFreeAudio = takenAudios.current.findIndex((a) => a === false);
         if (firstFreeAudio === -1) {
             throw new Error(`Tried to simultaneously mount ${numberOfAudioTags + 1} <Audio /> tags at the same time. With the current settings, the maximum amount of <Audio /> tags is limited to ${numberOfAudioTags} at the same time. Remotion pre-mounts silent audio tags to help avoid browser autoplay restrictions. See https://remotion.dev/docs/player/autoplay#use-the-numberofsharedaudiotags-property for more information on how to increase this limit.`);
@@ -53,17 +115,14 @@ const SharedAudioContextProvider = ({ children, numberOfAudioTags }) => {
             props: aud,
             id,
             el: ref,
+            audioId,
         };
-        // We need a timeout because this state setting is triggered by another state being set, causing React to throw an error.
-        // By setting a timeout, we are bypassing the error and allowing the state
-        // to be updated in the next tick.
-        // This can lead to a tiny delay of audio playback, improvement ideas are welcome.
-        setTimeout(() => {
-            setAudios((prevAudios) => [...prevAudios, newElem]);
-        }, 4);
+        (_b = audios.current) === null || _b === void 0 ? void 0 : _b.push(newElem);
+        rerenderAudios();
         return newElem;
-    }, [numberOfAudioTags, refs]);
+    }, [numberOfAudioTags, refs, rerenderAudios]);
     const unregisterAudio = (0, react_1.useCallback)((id) => {
+        var _a;
         const cloned = [...takenAudios.current];
         const index = refs.findIndex((r) => r.id === id);
         if (index === -1) {
@@ -71,23 +130,31 @@ const SharedAudioContextProvider = ({ children, numberOfAudioTags }) => {
         }
         cloned[index] = false;
         takenAudios.current = cloned;
-        setAudios((prevAudios) => {
-            return prevAudios.filter((a) => a.id !== id);
-        });
-    }, [refs]);
-    const updateAudio = (0, react_1.useCallback)((id, aud) => {
-        setAudios((prevAudios) => {
-            return prevAudios.map((prevA) => {
-                if (prevA.id === id) {
-                    return {
-                        ...prevA,
-                        props: aud,
-                    };
+        audios.current = (_a = audios.current) === null || _a === void 0 ? void 0 : _a.filter((a) => a.id !== id);
+        rerenderAudios();
+    }, [refs, rerenderAudios]);
+    const updateAudio = (0, react_1.useCallback)(({ aud, audioId, id, }) => {
+        var _a;
+        let changed = false;
+        audios.current = (_a = audios.current) === null || _a === void 0 ? void 0 : _a.map((prevA) => {
+            if (prevA.id === id) {
+                const isTheSame = compareProps(aud, prevA.props);
+                if (isTheSame) {
+                    return prevA;
                 }
-                return prevA;
-            });
+                changed = true;
+                return {
+                    ...prevA,
+                    props: aud,
+                    audioId,
+                };
+            }
+            return prevA;
         });
-    }, []);
+        if (changed) {
+            rerenderAudios();
+        }
+    }, [rerenderAudios]);
     const playAllAudios = (0, react_1.useCallback)(() => {
         refs.forEach((ref) => {
             var _a;
@@ -110,41 +177,46 @@ const SharedAudioContextProvider = ({ children, numberOfAudioTags }) => {
         updateAudio,
     ]);
     return ((0, jsx_runtime_1.jsxs)(exports.SharedAudioContext.Provider, { value: value, children: [refs.map(({ id, ref }) => {
-                const data = audios.find((a) => a.id === id);
-                if (data === undefined) {
-                    return (0, jsx_runtime_1.jsx)("audio", { ref: ref, src: EMPTY_AUDIO }, id);
-                }
-                if (!data) {
-                    throw new TypeError('Expected audio data to be there');
-                }
-                return (0, jsx_runtime_1.jsx)("audio", { ref: ref, ...data.props }, id);
+                return (0, jsx_runtime_1.jsx)("audio", { ref: ref, src: EMPTY_AUDIO }, id);
             }), children] }));
 };
 exports.SharedAudioContextProvider = SharedAudioContextProvider;
-const useSharedAudio = (aud) => {
+const useSharedAudio = (aud, audioId) => {
     const ctx = (0, react_1.useContext)(exports.SharedAudioContext);
+    /**
+     * We work around this in React 18 so an audio tag will only register itself once
+     */
     const [elem] = (0, react_1.useState)(() => {
         if (ctx && ctx.numberOfAudioTags > 0) {
-            return ctx.registerAudio(aud);
+            return ctx.registerAudio(aud, audioId);
         }
         return {
             el: react_1.default.createRef(),
             id: Math.random(),
             props: aud,
+            audioId,
         };
     });
-    (0, react_1.useEffect)(() => {
-        return () => {
+    /**
+     * Effects in React 18 fire twice, and we are looking for a way to only fire it once.
+     * - useInsertionEffect only fires once. If it's available we are in React 18.
+     * - useLayoutEffect only fires once in React 17.
+     */
+    const effectToUse = react_1.useInsertionEffect !== null && react_1.useInsertionEffect !== void 0 ? react_1.useInsertionEffect : react_1.useLayoutEffect;
+    if (typeof document !== 'undefined') {
+        effectToUse(() => {
             if (ctx && ctx.numberOfAudioTags > 0) {
-                ctx.unregisterAudio(elem.id);
+                ctx.updateAudio({ id: elem.id, aud, audioId });
             }
-        };
-    }, [ctx, elem.id]);
-    (0, react_1.useEffect)(() => {
-        if (ctx && ctx.numberOfAudioTags > 0) {
-            ctx.updateAudio(elem.id, aud);
-        }
-    }, [aud, ctx, elem.id]);
+        }, [aud, ctx, elem.id, audioId]);
+        effectToUse(() => {
+            return () => {
+                if (ctx && ctx.numberOfAudioTags > 0) {
+                    ctx.unregisterAudio(elem.id);
+                }
+            };
+        }, [ctx, elem.id]);
+    }
     return elem;
 };
 exports.useSharedAudio = useSharedAudio;

package/dist/audio/use-audio-frame.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useFrameForVolumeProp = exports.useMediaStartsAt = void 0;
 const react_1 = require("react");
-const sequencing_1 = require("../sequencing");
-const use_frame_1 = require("../use-frame");
+const Sequence_1 = require("../Sequence");
+const use_current_frame_1 = require("../use-current-frame");
 const useMediaStartsAt = () => {
     var _a;
-    const parentSequence = (0, react_1.useContext)(sequencing_1.SequenceContext);
+    const parentSequence = (0, react_1.useContext)(Sequence_1.SequenceContext);
     const startsAt = Math.min(0, (_a = parentSequence === null || parentSequence === void 0 ? void 0 : parentSequence.relativeFrom) !== null && _a !== void 0 ? _a : 0);
     return startsAt;
 };
@@ -16,7 +16,7 @@ exports.useMediaStartsAt = useMediaStartsAt;
  * we calculate the way more intuitive value for currentFrame
  */
 const useFrameForVolumeProp = () => {
-    const frame = (0, use_frame_1.useCurrentFrame)();
+    const frame = (0, use_current_frame_1.useCurrentFrame)();
     const startsAt = (0, exports.useMediaStartsAt)();
     return frame + startsAt;
 };

package/dist/config/input-props.js

@@ -13,21 +13,19 @@ const warnOnceSSRImport = () => {
     console.warn("  typeof window === 'undefined' ? {} : getInputProps()");
 };
 const getInputProps = () => {
-    if ((0, get_environment_1.getRemotionEnvironment)() === 'rendering') {
-        if (typeof window === 'undefined') {
-            warnOnceSSRImport();
-            return {};
-        }
-        const param = window.remotion_inputProps;
-        if (!param) {
-            return {};
-        }
-        const parsed = JSON.parse(param);
-        return parsed;
+    if (typeof window === 'undefined') {
+        warnOnceSSRImport();
+        return {};
     }
-    if ((0, get_environment_1.getRemotionEnvironment)() === 'preview') {
-        return process.env.INPUT_PROPS;
+    if ((0, get_environment_1.getRemotionEnvironment)() === 'player-development' ||
+        (0, get_environment_1.getRemotionEnvironment)() === 'player-production') {
+        throw new Error('You cannot call `getInputProps()` from a <Player>. Instead, the props are available as React props from component that you passed as `component` prop.');
     }
-    throw new Error('You cannot call `getInputProps()` from a <Player>. Instead, the props are available as React props from component that you passed as `component` prop.');
+    const param = window.remotion_inputProps;
+    if (!param) {
+        return {};
+    }
+    const parsed = JSON.parse(param);
+    return parsed;
 };
 exports.getInputProps = getInputProps;