@remotion/media 4.0.403 → 4.0.404

package/dist/audio/audio-for-rendering.js

@@ -1,196 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useLayoutEffect, useMemo, useState } from 'react';
-import { cancelRender, Html5Audio, Internals, random, useCurrentFrame, useDelayRender, useRemotionEnvironment, } from 'remotion';
-import { useMaxMediaCacheSize } from '../caches';
-import { applyVolume } from '../convert-audiodata/apply-volume';
-import { TARGET_SAMPLE_RATE } from '../convert-audiodata/resample-audiodata';
-import { frameForVolumeProp } from '../looped-frame';
-import { extractFrameViaBroadcastChannel } from '../video-extraction/extract-frame-via-broadcast-channel';
-export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted, loopVolumeCurveBehavior, delayRenderRetries, delayRenderTimeoutInMilliseconds, logLevel: overriddenLogLevel, loop, fallbackHtml5AudioProps, audioStreamIndex, showInTimeline, style, name, disallowFallbackToHtml5Audio, toneFrequency, trimAfter, trimBefore, }) => {
-    const defaultLogLevel = Internals.useLogLevel();
-    const logLevel = overriddenLogLevel ?? defaultLogLevel;
-    const frame = useCurrentFrame();
-    const absoluteFrame = Internals.useTimelinePosition();
-    const videoConfig = Internals.useUnsafeVideoConfig();
-    const { registerRenderAsset, unregisterRenderAsset } = useContext(Internals.RenderAssetManager);
-    const startsAt = Internals.useMediaStartsAt();
-    const environment = useRemotionEnvironment();
-    if (!videoConfig) {
-        throw new Error('No video config found');
-    }
-    if (!src) {
-        throw new TypeError('No `src` was passed to <Audio>.');
-    }
-    const { fps } = videoConfig;
-    const { delayRender, continueRender } = useDelayRender();
-    const [replaceWithHtml5Audio, setReplaceWithHtml5Audio] = useState(false);
-    const sequenceContext = useContext(Internals.SequenceContext);
-    // Generate a string that's as unique as possible for this asset
-    // but at the same time the same on all threads
-    const id = useMemo(() => `media-audio-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
-        src,
-        sequenceContext?.cumulatedFrom,
-        sequenceContext?.relativeFrom,
-        sequenceContext?.durationInFrames,
-    ]);
-    const maxCacheSize = useMaxMediaCacheSize(logLevel);
-    const audioEnabled = Internals.useAudioEnabled();
-    useLayoutEffect(() => {
-        const timestamp = frame / fps;
-        const durationInSeconds = 1 / fps;
-        const shouldRenderAudio = (() => {
-            if (!audioEnabled) {
-                return false;
-            }
-            if (muted) {
-                return false;
-            }
-            return true;
-        })();
-        if (!shouldRenderAudio) {
-            return;
-        }
-        if (replaceWithHtml5Audio) {
-            return;
-        }
-        const newHandle = delayRender(`Extracting audio for frame ${frame}`, {
-            retries: delayRenderRetries ?? undefined,
-            timeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined,
-        });
-        extractFrameViaBroadcastChannel({
-            src,
-            timeInSeconds: timestamp,
-            durationInSeconds,
-            playbackRate: playbackRate ?? 1,
-            logLevel,
-            includeAudio: shouldRenderAudio,
-            includeVideo: false,
-            isClientSideRendering: environment.isClientSideRendering,
-            loop: loop ?? false,
-            audioStreamIndex: audioStreamIndex ?? 0,
-            trimAfter,
-            trimBefore,
-            fps,
-            maxCacheSize,
-        })
-            .then((result) => {
-            if (result.type === 'unknown-container-format') {
-                if (environment.isClientSideRendering) {
-                    cancelRender(new Error(`Cannot render audio "${src}": Unknown container format. See supported formats: https://www.remotion.dev/docs/mediabunny/formats`));
-                    return;
-                }
-                if (disallowFallbackToHtml5Audio) {
-                    cancelRender(new Error(`Unknown container format ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
-                }
-                Internals.Log.warn({
-                    logLevel,
-                    tag: '@remotion/media',
-                }, `Unknown container format for ${src} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Html5Audio>`);
-                setReplaceWithHtml5Audio(true);
-                return;
-            }
-            if (result.type === 'cannot-decode') {
-                if (environment.isClientSideRendering) {
-                    cancelRender(new Error(`Cannot render audio "${src}": The audio could not be decoded by the browser.`));
-                    return;
-                }
-                if (disallowFallbackToHtml5Audio) {
-                    cancelRender(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
-                }
-                Internals.Log.warn({
-                    logLevel,
-                    tag: '@remotion/media',
-                }, `Cannot decode ${src}, falling back to <Html5Audio>`);
-                setReplaceWithHtml5Audio(true);
-                return;
-            }
-            if (result.type === 'cannot-decode-alpha') {
-                throw new Error(`Cannot decode alpha component for ${src}, and 'disallowFallbackToHtml5Audio' was set. But this should never happen, since you used the <Audio> tag. Please report this as a bug.`);
-            }
-            if (result.type === 'network-error') {
-                if (environment.isClientSideRendering) {
-                    cancelRender(new Error(`Cannot render audio "${src}": Network error while fetching the audio (possibly CORS).`));
-                    return;
-                }
-                if (disallowFallbackToHtml5Audio) {
-                    cancelRender(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
-                }
-                Internals.Log.warn({
-                    logLevel,
-                    tag: '@remotion/media',
-                }, `Network error fetching ${src}, falling back to <Html5Audio>`);
-                setReplaceWithHtml5Audio(true);
-                return;
-            }
-            const { audio, durationInSeconds: assetDurationInSeconds } = result;
-            const volumePropsFrame = frameForVolumeProp({
-                behavior: loopVolumeCurveBehavior ?? 'repeat',
-                loop: loop ?? false,
-                assetDurationInSeconds: assetDurationInSeconds ?? 0,
-                fps,
-                frame,
-                startsAt,
-            });
-            const volume = Internals.evaluateVolume({
-                volume: volumeProp,
-                frame: volumePropsFrame,
-                mediaVolume: 1,
-            });
-            Internals.warnAboutTooHighVolume(volume);
-            if (audio && volume > 0) {
-                applyVolume(audio.data, volume);
-                registerRenderAsset({
-                    type: 'inline-audio',
-                    id,
-                    audio: environment.isClientSideRendering
-                        ? audio.data
-                        : Array.from(audio.data),
-                    frame: absoluteFrame,
-                    timestamp: audio.timestamp,
-                    duration: (audio.numberOfFrames / TARGET_SAMPLE_RATE) * 1000000,
-                    toneFrequency: toneFrequency ?? 1,
-                });
-            }
-            continueRender(newHandle);
-        })
-            .catch((error) => {
-            cancelRender(error);
-        });
-        return () => {
-            continueRender(newHandle);
-            unregisterRenderAsset(id);
-        };
-    }, [
-        absoluteFrame,
-        continueRender,
-        delayRender,
-        delayRenderRetries,
-        delayRenderTimeoutInMilliseconds,
-        disallowFallbackToHtml5Audio,
-        environment.isClientSideRendering,
-        fps,
-        frame,
-        id,
-        logLevel,
-        loop,
-        loopVolumeCurveBehavior,
-        muted,
-        playbackRate,
-        registerRenderAsset,
-        src,
-        startsAt,
-        unregisterRenderAsset,
-        volumeProp,
-        audioStreamIndex,
-        toneFrequency,
-        trimAfter,
-        trimBefore,
-        replaceWithHtml5Audio,
-        maxCacheSize,
-        audioEnabled,
-    ]);
-    if (replaceWithHtml5Audio) {
-        return (_jsx(Html5Audio, { src: src, playbackRate: playbackRate, muted: muted, loop: loop, volume: volumeProp, delayRenderRetries: delayRenderRetries, delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds, style: style, loopVolumeCurveBehavior: loopVolumeCurveBehavior, audioStreamIndex: audioStreamIndex, useWebAudioApi: fallbackHtml5AudioProps?.useWebAudioApi, onError: fallbackHtml5AudioProps?.onError, toneFrequency: toneFrequency, acceptableTimeShiftInSeconds: fallbackHtml5AudioProps?.acceptableTimeShiftInSeconds, name: name, showInTimeline: showInTimeline }));
-    }
-    return null;
-};

package/dist/audio/audio-preview-iterator.js

@@ -1,176 +0,0 @@
-import { roundTo4Digits } from '../helpers/round-to-4-digits';
-import { allowWaitRoutine } from './allow-wait';
-export const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
-export const makeAudioIterator = (startFromSecond, cache) => {
-    let destroyed = false;
-    const iterator = cache.makeIteratorOrUsePrewarmed(startFromSecond);
-    const queuedAudioNodes = [];
-    const audioChunksForAfterResuming = [];
-    let mostRecentTimestamp = -Infinity;
-    const cleanupAudioQueue = () => {
-        for (const node of queuedAudioNodes) {
-            node.node.stop();
-        }
-        queuedAudioNodes.length = 0;
-    };
-    const getNextOrNullIfNotAvailable = async (allowWait) => {
-        const next = iterator.next();
-        const result = allowWait
-            ? await allowWaitRoutine(next, allowWait)
-            : await Promise.race([
-                next,
-                new Promise((resolve) => {
-                    Promise.resolve().then(() => resolve());
-                }),
-            ]);
-        if (!result) {
-            return {
-                type: 'need-to-wait-for-it',
-                waitPromise: async () => {
-                    const res = await next;
-                    return res.value;
-                },
-            };
-        }
-        if (result.value) {
-            mostRecentTimestamp = Math.max(mostRecentTimestamp, result.value.timestamp + result.value.duration);
-            return {
-                type: 'got-buffer',
-                buffer: result.value,
-            };
-        }
-        return {
-            type: 'got-end',
-            mostRecentTimestamp,
-        };
-    };
-    const tryToSatisfySeek = async (time, allowWait, onBufferScheduled) => {
-        if (time < startFromSecond) {
-            return {
-                type: 'not-satisfied',
-                reason: `time requested is before the start of the iterator`,
-            };
-        }
-        while (true) {
-            const buffer = await getNextOrNullIfNotAvailable(allowWait);
-            if (buffer.type === 'need-to-wait-for-it') {
-                return {
-                    type: 'not-satisfied',
-                    reason: 'iterator did not have buffer ready',
-                };
-            }
-            if (buffer.type === 'got-end') {
-                if (time >= mostRecentTimestamp) {
-                    return {
-                        type: 'ended',
-                    };
-                }
-                return {
-                    type: 'not-satisfied',
-                    reason: `iterator ended before the requested time`,
-                };
-            }
-            if (buffer.type === 'got-buffer') {
-                const bufferTimestamp = roundTo4Digits(buffer.buffer.timestamp);
-                const bufferEndTimestamp = roundTo4Digits(buffer.buffer.timestamp + buffer.buffer.duration);
-                const timestamp = roundTo4Digits(time);
-                if (roundTo4Digits(time) < bufferTimestamp) {
-                    return {
-                        type: 'not-satisfied',
-                        reason: `iterator is too far, most recently returned ${bufferTimestamp}-${bufferEndTimestamp}, requested ${time}`,
-                    };
-                }
-                if (bufferTimestamp <= timestamp && bufferEndTimestamp > timestamp) {
-                    onBufferScheduled(buffer.buffer);
-                    return {
-                        type: 'satisfied',
-                    };
-                }
-                onBufferScheduled(buffer.buffer);
-                continue;
-            }
-            throw new Error('Unreachable');
-        }
-    };
-    const removeAndReturnAllQueuedAudioNodes = () => {
-        const nodes = queuedAudioNodes.slice();
-        for (const node of nodes) {
-            node.node.stop();
-        }
-        queuedAudioNodes.length = 0;
-        return nodes;
-    };
-    const addChunkForAfterResuming = (buffer, timestamp) => {
-        audioChunksForAfterResuming.push({ buffer, timestamp });
-    };
-    const moveQueuedChunksToPauseQueue = () => {
-        const toQueue = removeAndReturnAllQueuedAudioNodes();
-        for (const chunk of toQueue) {
-            addChunkForAfterResuming(chunk.buffer, chunk.timestamp);
-        }
-    };
-    const getNumberOfChunksAfterResuming = () => {
-        return audioChunksForAfterResuming.length;
-    };
-    return {
-        destroy: () => {
-            cleanupAudioQueue();
-            destroyed = true;
-            iterator.return().catch(() => undefined);
-            audioChunksForAfterResuming.length = 0;
-        },
-        getNext: async () => {
-            const next = await iterator.next();
-            if (next.value) {
-                mostRecentTimestamp = Math.max(mostRecentTimestamp, next.value.timestamp + next.value.duration);
-            }
-            return next;
-        },
-        isDestroyed: () => {
-            return destroyed;
-        },
-        addQueuedAudioNode: (node, timestamp, buffer) => {
-            queuedAudioNodes.push({ node, timestamp, buffer });
-        },
-        removeQueuedAudioNode: (node) => {
-            const index = queuedAudioNodes.findIndex((n) => n.node === node);
-            if (index !== -1) {
-                queuedAudioNodes.splice(index, 1);
-            }
-        },
-        getAndClearAudioChunksForAfterResuming: () => {
-            const chunks = audioChunksForAfterResuming.slice();
-            audioChunksForAfterResuming.length = 0;
-            return chunks;
-        },
-        getQueuedPeriod: () => {
-            let until = -Infinity;
-            let from = Infinity;
-            for (const node of queuedAudioNodes) {
-                until = Math.max(until, node.timestamp + node.buffer.duration);
-                from = Math.min(from, node.timestamp);
-            }
-            for (const chunk of audioChunksForAfterResuming) {
-                until = Math.max(until, chunk.timestamp + chunk.buffer.duration);
-                from = Math.min(from, chunk.timestamp);
-            }
-            if (!Number.isFinite(from) || !Number.isFinite(until)) {
-                return null;
-            }
-            return {
-                from,
-                until,
-            };
-        },
-        tryToSatisfySeek,
-        addChunkForAfterResuming,
-        moveQueuedChunksToPauseQueue,
-        getNumberOfChunksAfterResuming,
-    };
-};
-export const isAlreadyQueued = (time, queuedPeriod) => {
-    if (!queuedPeriod) {
-        return false;
-    }
-    return time >= queuedPeriod.from && time < queuedPeriod.until;
-};

package/dist/audio/audio.js

@@ -1,20 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Internals, useRemotionEnvironment } from 'remotion';
-import { AudioForPreview } from './audio-for-preview';
-import { AudioForRendering } from './audio-for-rendering';
-const { validateMediaProps } = Internals;
-export const Audio = (props) => {
-    // Should only destruct `trimBefore` and `trimAfter` from props,
-    // rest gets drilled down
-    const { name, stack, showInTimeline, ...otherProps } = props;
-    const environment = useRemotionEnvironment();
-    if (typeof props.src !== 'string') {
-        throw new TypeError(`The \`<Audio>\` tag requires a string for \`src\`, but got ${JSON.stringify(props.src)} instead.`);
-    }
-    validateMediaProps({ playbackRate: props.playbackRate, volume: props.volume }, 'Audio');
-    if (environment.isRendering) {
-        return _jsx(AudioForRendering, { ...otherProps });
-    }
-    return _jsx(AudioForPreview, { name: name, ...otherProps, stack: stack ?? null });
-};
-Internals.addSequenceStackTraces(Audio);

package/dist/audio/props.js

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

package/dist/audio-extraction/audio-cache.js

@@ -1,66 +0,0 @@
-export const makeAudioCache = () => {
-    const timestamps = [];
-    const samples = {};
-    const addFrame = (sample) => {
-        timestamps.push(sample.timestamp);
-        samples[sample.timestamp] = sample;
-    };
-    const clearBeforeThreshold = (threshold) => {
-        for (const timestamp of timestamps.slice()) {
-            const endTimestamp = timestamp + samples[timestamp].duration;
-            if (endTimestamp < threshold) {
-                const isLast = timestamp === timestamps[timestamps.length - 1];
-                if (isLast) {
-                    continue;
-                }
-                samples[timestamp].close();
-                delete samples[timestamp];
-                timestamps.splice(timestamps.indexOf(timestamp), 1);
-            }
-        }
-    };
-    const deleteAll = () => {
-        for (const timestamp of timestamps) {
-            samples[timestamp].close();
-            delete samples[timestamp];
-        }
-        timestamps.length = 0;
-    };
-    const getSamples = (timestamp, durationInSeconds) => {
-        const selected = [];
-        for (let i = 0; i < timestamps.length; i++) {
-            const sampleTimestamp = timestamps[i];
-            const sample = samples[sampleTimestamp];
-            if (sample.timestamp + sample.duration - 0.0000000001 <= timestamp) {
-                continue;
-            }
-            if (sample.timestamp >= timestamp + durationInSeconds - 0.0000000001) {
-                break;
-            }
-            selected.push(sample);
-        }
-        return selected;
-    };
-    const getOpenTimestamps = () => {
-        return timestamps;
-    };
-    const getOldestTimestamp = () => {
-        return timestamps[0];
-    };
-    const getNewestTimestamp = () => {
-        if (timestamps.length === 0) {
-            return null;
-        }
-        const sample = samples[timestamps[timestamps.length - 1]];
-        return sample.timestamp + sample.duration;
-    };
-    return {
-        addFrame,
-        clearBeforeThreshold,
-        deleteAll,
-        getSamples,
-        getOldestTimestamp,
-        getNewestTimestamp,
-        getOpenTimestamps,
-    };
-};

package/dist/audio-extraction/audio-iterator.js

@@ -1,132 +0,0 @@
-import { Internals } from 'remotion';
-import { SAFE_WINDOW_OF_MONOTONICITY } from '../caches';
-import { makeAudioCache } from './audio-cache';
-// https://discord.com/channels/@me/1409810025844838481/1415028953093111870
-// Audio frames might have dependencies on previous and next frames so we need to decode a bit more
-// and then discard it.
-// The worst case seems to be FLAC files with a 65'535 sample window, which would be 1486.0ms at 44.1Khz.
-// So let's set a threshold of 1.5 seconds.
-const extraThreshold = 1.5;
-const warned = {};
-const warnAboutMatroskaOnce = (src, logLevel) => {
-    if (warned[src]) {
-        return;
-    }
-    warned[src] = true;
-    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Audio from ${src} will need to be read from the beginning. https://www.remotion.dev/docs/media/support#matroska-limitation`);
-};
-export const makeAudioIterator = ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, logLevel, }) => {
-    // Matroska timestamps are not accurate unless we start from the beginning
-    // So for matroska, we need to decode all samples :(
-    // https://github.com/Vanilagy/mediabunny/issues/105
-    const sampleIterator = audioSampleSink.samples(isMatroska ? 0 : Math.max(0, startTimestamp - extraThreshold));
-    if (isMatroska) {
-        warnAboutMatroskaOnce(src, logLevel);
-    }
-    let fullDuration = null;
-    const cache = makeAudioCache();
-    let lastUsed = Date.now();
-    const getNextSample = async () => {
-        lastUsed = Date.now();
-        const { value: sample, done } = await sampleIterator.next();
-        if (done) {
-            fullDuration = cache.getNewestTimestamp();
-            return null;
-        }
-        const realTimestamp = actualMatroskaTimestamps.getRealTimestamp(sample.timestamp);
-        if (realTimestamp !== null && realTimestamp !== sample.timestamp) {
-            sample.setTimestamp(realTimestamp);
-        }
-        actualMatroskaTimestamps.observeTimestamp(sample.timestamp);
-        actualMatroskaTimestamps.observeTimestamp(sample.timestamp + sample.duration);
-        cache.addFrame(sample);
-        return sample;
-    };
-    const getSamples = async (timestamp, durationInSeconds) => {
-        lastUsed = Date.now();
-        if (fullDuration !== null && timestamp > fullDuration) {
-            // Clear all samples before the timestamp
-            // Do this in the while loop because samples might start from 0
-            cache.clearBeforeThreshold(fullDuration - SAFE_WINDOW_OF_MONOTONICITY);
-            return [];
-        }
-        const samples = cache.getSamples(timestamp, durationInSeconds);
-        const newestTimestamp = cache.getNewestTimestamp();
-        if (newestTimestamp !== null) {
-            if (newestTimestamp >= timestamp + durationInSeconds - 0.0000000001) {
-                return samples;
-            }
-        }
-        while (true) {
-            const sample = await getNextSample();
-            // Clear all samples before the timestamp
-            // Do this in the while loop because samples might start from 0
-            // Also do this after a sample has just been added, if it was the last sample we now have the duration
-            // and can prevent deleting the last sample
-            const deleteBefore = fullDuration === null ? timestamp : Math.min(timestamp, fullDuration);
-            cache.clearBeforeThreshold(deleteBefore - SAFE_WINDOW_OF_MONOTONICITY);
-            if (sample === null) {
-                break;
-            }
-            if (sample.timestamp + sample.duration - 0.0000000001 <= timestamp) {
-                continue;
-            }
-            if (sample.timestamp >= timestamp + durationInSeconds - 0.0000000001) {
-                break;
-            }
-            samples.push(sample);
-        }
-        return samples;
-    };
-    const logOpenFrames = () => {
-        const openTimestamps = cache.getOpenTimestamps();
-        if (openTimestamps.length > 0) {
-            const first = openTimestamps[0];
-            const last = openTimestamps[openTimestamps.length - 1];
-            Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, 'Open audio samples for src', src, `${first.toFixed(3)}...${last.toFixed(3)}`);
-        }
-    };
-    const getCacheStats = () => {
-        return {
-            count: cache.getOpenTimestamps().length,
-            size: cache.getOpenTimestamps().reduce((acc, t) => acc + t, 0),
-        };
-    };
-    const canSatisfyRequestedTime = (timestamp) => {
-        const oldestTimestamp = cache.getOldestTimestamp() ?? startTimestamp;
-        if (fullDuration !== null && timestamp > fullDuration) {
-            return true;
-        }
-        return (oldestTimestamp < timestamp && Math.abs(oldestTimestamp - timestamp) < 10);
-    };
-    const prepareForDeletion = () => {
-        cache.deleteAll();
-        sampleIterator.return().then((value) => {
-            if (value.value) {
-                value.value.close();
-            }
-        });
-        fullDuration = null;
-    };
-    let op = Promise.resolve([]);
-    return {
-        src,
-        getSamples: (ts, dur) => {
-            op = op.then(() => getSamples(ts, dur));
-            return op;
-        },
-        waitForCompletion: async () => {
-            await op;
-            return true;
-        },
-        canSatisfyRequestedTime,
-        logOpenFrames,
-        getCacheStats,
-        getLastUsed: () => lastUsed,
-        prepareForDeletion,
-        startTimestamp,
-        clearBeforeThreshold: cache.clearBeforeThreshold,
-        getOldestTimestamp: cache.getOldestTimestamp,
-        getNewestTimestamp: cache.getNewestTimestamp,
-    };
-};