@remotion/media 4.0.374 → 4.0.376

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

@@ -1,6 +1,7 @@
 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';
@@ -30,6 +31,7 @@ export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted
         sequenceContext?.relativeFrom,
         sequenceContext?.durationInFrames,
     ]);
+    const maxCacheSize = useMaxMediaCacheSize(logLevel ?? window.remotion_logLevel);
     useLayoutEffect(() => {
         const timestamp = frame / fps;
         const durationInSeconds = 1 / fps;
@@ -63,6 +65,7 @@ export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted
             trimAfter,
             trimBefore,
             fps,
+            maxCacheSize,
         })
             .then((result) => {
             if (result.type === 'unknown-container-format') {
@@ -163,6 +166,7 @@ export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted
         trimAfter,
         trimBefore,
         replaceWithHtml5Audio,
+        maxCacheSize,
     ]);
     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 }));

package/dist/audio/audio-preview-iterator.d.ts

@@ -23,6 +23,8 @@ export declare const makeAudioIterator: (audioSink: AudioBufferSink, startFromSe
     tryToSatisfySeek: (time: number, allowWait: AllowWait | null, onBufferScheduled: (buffer: WrappedAudioBuffer) => void) => Promise<{
         type: "not-satisfied";
         reason: string;
+    } | {
+        type: "ended";
     } | {
         type: "satisfied";
     }>;

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

@@ -12,8 +12,6 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
         }
         queuedAudioNodes.length = 0;
     };
-    let lastReturnedBuffer = null;
-    let iteratorEnded = false;
     const getNextOrNullIfNotAvailable = async (allowWait) => {
         const next = iterator.next();
         const result = allowWait
@@ -29,53 +27,16 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
                 type: 'need-to-wait-for-it',
                 waitPromise: async () => {
                     const res = await next;
-                    if (res.value) {
-                        lastReturnedBuffer = res.value;
-                    }
-                    else {
-                        iteratorEnded = true;
-                    }
                     return res.value;
                 },
             };
         }
-        if (result.value) {
-            lastReturnedBuffer = result.value;
-        }
-        else {
-            iteratorEnded = true;
-        }
         return {
             type: 'got-buffer-or-end',
             buffer: result.value ?? null,
         };
     };
     const tryToSatisfySeek = async (time, allowWait, onBufferScheduled) => {
-        if (lastReturnedBuffer) {
-            const bufferTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp);
-            const bufferEndTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp + lastReturnedBuffer.duration);
-            if (roundTo4Digits(time) < bufferTimestamp) {
-                return {
-                    type: 'not-satisfied',
-                    reason: `iterator is too far, most recently returned ${bufferTimestamp}-${bufferEndTimestamp}, requested ${time}`,
-                };
-            }
-            if (roundTo4Digits(time) <= bufferEndTimestamp) {
-                onBufferScheduled(lastReturnedBuffer);
-                return {
-                    type: 'satisfied',
-                };
-            }
-            // fall through
-        }
-        if (iteratorEnded) {
-            if (lastReturnedBuffer) {
-                onBufferScheduled(lastReturnedBuffer);
-            }
-            return {
-                type: 'satisfied',
-            };
-        }
         while (true) {
             const buffer = await getNextOrNullIfNotAvailable(allowWait);
             if (buffer.type === 'need-to-wait-for-it') {
@@ -86,17 +47,19 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             }
             if (buffer.type === 'got-buffer-or-end') {
                 if (buffer.buffer === null) {
-                    iteratorEnded = true;
-                    if (lastReturnedBuffer) {
-                        onBufferScheduled(lastReturnedBuffer);
-                    }
                     return {
-                        type: 'satisfied',
+                        type: 'ended',
                     };
                 }
                 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 {
@@ -138,12 +101,6 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
         },
         getNext: async () => {
             const next = await iterator.next();
-            if (next.value) {
-                lastReturnedBuffer = next.value;
-            }
-            else {
-                iteratorEnded = true;
-            }
             return next;
         },
         isDestroyed: () => {

package/dist/audio-extraction/audio-manager.d.ts

@@ -3,13 +3,14 @@ import { type LogLevel } from 'remotion';
 import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
 import type { AudioSampleIterator } from './audio-iterator';
 export declare const makeAudioManager: () => {
-    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }: {
+    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }: {
         src: string;
         timeInSeconds: number;
         audioSampleSink: AudioSampleSink;
         isMatroska: boolean;
         actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
         logLevel: LogLevel;
+        maxCacheSize: number;
     }) => Promise<AudioSampleIterator>;
     getCacheStats: () => {
         count: number;

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

@@ -1,5 +1,5 @@
 import { Internals } from 'remotion';
-import { getMaxVideoCacheSize, getTotalCacheStats } from '../caches';
+import { getTotalCacheStats } from '../caches';
 import { makeAudioIterator } from './audio-iterator';
 export const makeAudioManager = () => {
     const iterators = [];
@@ -47,8 +47,7 @@ export const makeAudioManager = () => {
             seenKeys.add(key);
         }
     };
-    const getIterator = async ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }) => {
-        const maxCacheSize = getMaxVideoCacheSize(logLevel);
+    const getIterator = async ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }) => {
         while ((await getTotalCacheStats()).totalSize > maxCacheSize) {
             deleteOldestIterator();
         }
@@ -94,7 +93,7 @@ export const makeAudioManager = () => {
     };
     let queue = Promise.resolve(undefined);
     return {
-        getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }) => {
+        getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }) => {
             queue = queue.then(() => getIterator({
                 src,
                 timeInSeconds,
@@ -102,6 +101,7 @@ export const makeAudioManager = () => {
                 isMatroska,
                 actualMatroskaTimestamps,
                 logLevel,
+                maxCacheSize,
             }));
             return queue;
         },

package/dist/audio-extraction/extract-audio.d.ts

@@ -12,8 +12,9 @@ type ExtractAudioParams = {
     trimBefore: number | undefined;
     trimAfter: number | undefined;
     fps: number;
+    maxCacheSize: number;
 };
-declare const extractAudioInternal: ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds: durationNotYetApplyingPlaybackRate, logLevel, loop, playbackRate, audioStreamIndex, trimBefore, trimAfter, fps, }: ExtractAudioParams) => Promise<{
+declare const extractAudioInternal: ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds: durationNotYetApplyingPlaybackRate, logLevel, loop, playbackRate, audioStreamIndex, trimBefore, trimAfter, fps, maxCacheSize, }: ExtractAudioParams) => Promise<{
     data: PcmS16AudioData | null;
     durationInSeconds: number | null;
 } | "cannot-decode" | "unknown-container-format">;

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

@@ -1,9 +1,10 @@
 import { audioManager } from '../caches';
 import { combineAudioDataAndClosePrevious } from '../convert-audiodata/combine-audiodata';
-import { convertAudioData } from '../convert-audiodata/convert-audiodata';
+import { convertAudioData, fixFloatingPoint, } from '../convert-audiodata/convert-audiodata';
+import { TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from '../convert-audiodata/resample-audiodata';
 import { getSink } from '../get-sink';
 import { getTimeInSeconds } from '../get-time-in-seconds';
-const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds: durationNotYetApplyingPlaybackRate, logLevel, loop, playbackRate, audioStreamIndex, trimBefore, trimAfter, fps, }) => {
+const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds: durationNotYetApplyingPlaybackRate, logLevel, loop, playbackRate, audioStreamIndex, trimBefore, trimAfter, fps, maxCacheSize, }) => {
     const { getAudio, actualMatroskaTimestamps, isMatroska, getDuration } = await getSink(src, logLevel);
     let mediaDurationInSeconds = null;
     if (loop) {
@@ -40,11 +41,11 @@ const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds,
         isMatroska,
         actualMatroskaTimestamps,
         logLevel,
+        maxCacheSize,
     });
     const durationInSeconds = durationNotYetApplyingPlaybackRate * playbackRate;
     const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
     audioManager.logOpenFrames();
-    const trimStartToleranceInSeconds = 0.002;
     const audioDataArray = [];
     for (let i = 0; i < samples.length; i++) {
         const sample = samples[i];
@@ -64,14 +65,18 @@ const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds,
         // amount of samples to shave from start and end
         let trimStartInSeconds = 0;
         let trimEndInSeconds = 0;
+        let leadingSilence = null;
         if (isFirstSample) {
-            trimStartInSeconds = timeInSeconds - sample.timestamp;
-            if (trimStartInSeconds < 0 &&
-                trimStartInSeconds > -trimStartToleranceInSeconds) {
-                trimStartInSeconds = 0;
-            }
+            trimStartInSeconds = fixFloatingPoint(timeInSeconds - sample.timestamp);
             if (trimStartInSeconds < 0) {
-                throw new Error(`trimStartInSeconds is negative: ${trimStartInSeconds}. ${JSON.stringify({ timeInSeconds, ts: sample.timestamp, d: sample.duration, isFirstSample, isLastSample, durationInSeconds, i, st: samples.map((s) => s.timestamp) })}`);
+                const silenceFrames = Math.ceil(fixFloatingPoint(-trimStartInSeconds * TARGET_SAMPLE_RATE));
+                leadingSilence = {
+                    data: new Int16Array(silenceFrames * TARGET_NUMBER_OF_CHANNELS),
+                    numberOfFrames: silenceFrames,
+                    timestamp: timeInSeconds * 1000000,
+                    durationInMicroSeconds: (silenceFrames / TARGET_SAMPLE_RATE) * 1000000,
+                };
+                trimStartInSeconds = 0;
             }
         }
         if (isLastSample) {
@@ -93,6 +98,9 @@ const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds,
         if (audioData.numberOfFrames === 0) {
             continue;
         }
+        if (leadingSilence) {
+            audioDataArray.push(leadingSilence);
+        }
         audioDataArray.push(audioData);
     }
     if (audioDataArray.length === 0) {

package/dist/audio-iterator-manager.d.ts

@@ -37,6 +37,8 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
         tryToSatisfySeek: (time: number, allowWait: import("./audio/allow-wait").AllowWait | null, onBufferScheduled: (buffer: WrappedAudioBuffer) => void) => Promise<{
             type: "not-satisfied";
             reason: string;
+        } | {
+            type: "ended";
         } | {
             type: "satisfied";
         }>;

package/dist/audio-iterator-manager.js

@@ -117,6 +117,9 @@ export const audioIteratorManager = ({ audioTrack, delayPlaybackHandleIfNotPremo
             if (nonce.isStale()) {
                 return;
             }
+            if (audioSatisfyResult.type === 'ended') {
+                return;
+            }
             if (audioSatisfyResult.type === 'not-satisfied') {
                 await startAudioIterator({
                     nonce,
@@ -157,6 +160,9 @@ export const audioIteratorManager = ({ audioTrack, delayPlaybackHandleIfNotPremo
             if (nonce.isStale()) {
                 return;
             }
+            if (audioSatisfyResult.type === 'ended') {
+                return;
+            }
             if (audioSatisfyResult.type === 'not-satisfied') {
                 await startAudioIterator({
                     nonce,

package/dist/caches.d.ts

@@ -1,12 +1,13 @@
 import { type LogLevel } from 'remotion';
 export declare const SAFE_BACK_WINDOW_IN_SECONDS = 1;
 export declare const keyframeManager: {
-    requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, }: {
+    requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, maxCacheSize, }: {
         packetSink: import("mediabunny").EncodedPacketSink;
         timestamp: number;
         videoSampleSink: import("mediabunny").VideoSampleSink;
         src: string;
         logLevel: LogLevel;
+        maxCacheSize: number;
     }) => Promise<import("./video-extraction/keyframe-bank").KeyframeBank | "has-alpha" | null>;
     getCacheStats: () => Promise<{
         count: number;
@@ -15,13 +16,14 @@ export declare const keyframeManager: {
     clearAll: (logLevel: LogLevel) => Promise<void>;
 };
 export declare const audioManager: {
-    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }: {
+    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }: {
         src: string;
         timeInSeconds: number;
         audioSampleSink: import("mediabunny").AudioSampleSink;
         isMatroska: boolean;
         actualMatroskaTimestamps: import("./video-extraction/remember-actual-matroska-timestamps").RememberActualMatroskaTimestamps;
         logLevel: LogLevel;
+        maxCacheSize: number;
     }) => Promise<import("./audio-extraction/audio-iterator").AudioSampleIterator>;
     getCacheStats: () => {
         count: number;
@@ -52,3 +54,4 @@ export declare const getTotalCacheStats: () => Promise<{
     totalSize: number;
 }>;
 export declare const getMaxVideoCacheSize: (logLevel: LogLevel) => number;
+export declare const useMaxMediaCacheSize: (logLevel: LogLevel) => number;

package/dist/caches.js

@@ -1,3 +1,4 @@
+import React from 'react';
 import { cancelRender, Internals } from 'remotion';
 import { makeAudioManager } from './audio-extraction/audio-manager';
 import { makeKeyframeManager } from './video-extraction/keyframe-manager';
@@ -51,3 +52,10 @@ export const getMaxVideoCacheSize = (logLevel) => {
     cachedMaxCacheSize = getUncachedMaxCacheSize(logLevel);
     return cachedMaxCacheSize;
 };
+export const useMaxMediaCacheSize = (logLevel) => {
+    const context = React.useContext(Internals.MaxMediaCacheSizeContext);
+    if (context === null) {
+        return getMaxVideoCacheSize(logLevel);
+    }
+    return context;
+};

package/dist/convert-audiodata/convert-audiodata.js

@@ -1,11 +1,12 @@
 import { resampleAudioData, TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from './resample-audiodata';
 const FORMAT = 's16';
 export const fixFloatingPoint = (value) => {
-    if (value % 1 < 0.0000001) {
-        return Math.floor(value);
+    const decimal = Math.abs(value % 1);
+    if (decimal < 0.0000001) {
+        return value < 0 ? Math.ceil(value) : Math.floor(value);
     }
-    if (value % 1 > 0.9999999) {
-        return Math.ceil(value);
+    if (decimal > 0.9999999) {
+        return value < 0 ? Math.floor(value) : Math.ceil(value);
     }
     return value;
 };