@remotion/media 4.0.351 → 4.0.353

package/dist/audio/props.d.ts

@@ -1,5 +1,4 @@
-import type { LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
-import type { LogLevel } from '../log';
+import type { LogLevel, LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
 export type AudioProps = {
     src: string;
     trimBefore?: number;

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

@@ -9,6 +9,10 @@ export const makeAudioCache = () => {
         for (const timestamp of timestamps) {
             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);

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

@@ -1,5 +1,5 @@
 import type { AudioSample, AudioSampleSink } from 'mediabunny';
-import type { LogLevel } from '../log';
+import { type LogLevel } from 'remotion';
 import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
 export declare const makeAudioIterator: ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, }: {
     audioSampleSink: AudioSampleSink;

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

@@ -1,5 +1,5 @@
+import { Internals } from 'remotion';
 import { SAFE_BACK_WINDOW_IN_SECONDS } from '../caches';
-import { Log } from '../log';
 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
@@ -41,10 +41,13 @@ export const makeAudioIterator = ({ audioSampleSink, isMatroska, startTimestamp,
         }
         const samples = cache.getSamples(timestamp, durationInSeconds);
         while (true) {
+            const sample = await getNextSample();
             // Clear all samples before the timestamp
             // Do this in the while loop because samples might start from 0
-            cache.clearBeforeThreshold(timestamp - SAFE_BACK_WINDOW_IN_SECONDS);
-            const sample = await getNextSample();
+            // 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_BACK_WINDOW_IN_SECONDS);
             if (sample === null) {
                 break;
             }
@@ -59,7 +62,7 @@ export const makeAudioIterator = ({ audioSampleSink, isMatroska, startTimestamp,
         return samples;
     };
     const logOpenFrames = (logLevel) => {
-        Log.verbose(logLevel, '[Audio] Open samples for src', src, cache
+        Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, 'Open audio samples for src', src, cache
             .getOpenTimestamps()
             .map((t) => t.toFixed(3))
             .join(', '));

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

@@ -1,5 +1,5 @@
 import type { AudioSampleSink } from 'mediabunny';
-import type { LogLevel } from '../log';
+import type { LogLevel } from 'remotion';
 import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
 export declare const makeAudioManager: () => {
     makeIterator: ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
@@ -22,12 +22,13 @@ export declare const makeAudioManager: () => {
         prepareForDeletion: () => Promise<void>;
         startTimestamp: number;
     };
-    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }: {
         src: string;
         timeInSeconds: number;
         audioSampleSink: AudioSampleSink;
         isMatroska: boolean;
         actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
+        logLevel: LogLevel;
     }) => Promise<{
         src: string;
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;

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

@@ -1,4 +1,4 @@
-import { getTotalCacheStats, MAX_CACHE_SIZE } from '../caches';
+import { getMaxVideoCacheSize, getTotalCacheStats } from '../caches';
 import { makeAudioIterator } from './audio-iterator';
 export const makeAudioManager = () => {
     const iterators = [];
@@ -32,8 +32,9 @@ export const makeAudioManager = () => {
             iterators.splice(iterators.indexOf(iterator), 1);
         }
     };
-    const getIterator = async ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, }) => {
-        while ((await getTotalCacheStats()).totalSize > MAX_CACHE_SIZE) {
+    const getIterator = async ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }) => {
+        const maxCacheSize = getMaxVideoCacheSize(logLevel);
+        while ((await getTotalCacheStats()).totalSize > maxCacheSize) {
             await deleteOldestIterator();
         }
         for (const iterator of iterators) {

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

@@ -1,5 +1,5 @@
+import { type LogLevel } from 'remotion';
 import type { PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
-import type { LogLevel } from '../log';
 export declare const extractAudio: ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds, volume, logLevel, loop, }: {
     src: string;
     timeInSeconds: number;

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

@@ -21,6 +21,7 @@ export const extractAudio = async ({ src, timeInSeconds: unloopedTimeInSeconds,
         audioSampleSink: audio.sampleSink,
         isMatroska,
         actualMatroskaTimestamps,
+        logLevel,
     });
     const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
     audioManager.logOpenFrames(logLevel);

package/dist/caches.d.ts

@@ -1,4 +1,4 @@
-export declare const MAX_CACHE_SIZE: number;
+import { type LogLevel } from 'remotion';
 export declare const SAFE_BACK_WINDOW_IN_SECONDS = 1;
 export declare const keyframeManager: {
     requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, }: {
@@ -6,7 +6,7 @@ export declare const keyframeManager: {
         packetSink: import("mediabunny").EncodedPacketSink;
         videoSampleSink: import("mediabunny").VideoSampleSink;
         src: string;
-        logLevel: import("./log").LogLevel;
+        logLevel: LogLevel;
     }) => Promise<import("./video-extraction/keyframe-bank").KeyframeBank>;
     addKeyframeBank: ({ src, bank, startTimestampInSeconds, }: {
         src: string;
@@ -31,7 +31,7 @@ export declare const audioManager: {
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+        logOpenFrames: (logLevel: LogLevel) => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -40,18 +40,19 @@ export declare const audioManager: {
         prepareForDeletion: () => Promise<void>;
         startTimestamp: number;
     };
-    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }: {
         src: string;
         timeInSeconds: number;
         audioSampleSink: import("mediabunny").AudioSampleSink;
         isMatroska: boolean;
         actualMatroskaTimestamps: import("./video-extraction/remember-actual-matroska-timestamps").RememberActualMatroskaTimestamps;
+        logLevel: LogLevel;
     }) => Promise<{
         src: string;
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+        logOpenFrames: (logLevel: LogLevel) => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -69,7 +70,7 @@ export declare const audioManager: {
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+        logOpenFrames: (logLevel: LogLevel) => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -78,9 +79,10 @@ export declare const audioManager: {
         prepareForDeletion: () => Promise<void>;
         startTimestamp: number;
     } | null;
-    logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+    logOpenFrames: (logLevel: LogLevel) => void;
 };
 export declare const getTotalCacheStats: () => Promise<{
     count: number;
     totalSize: number;
 }>;
+export declare const getMaxVideoCacheSize: (logLevel: LogLevel) => number;

package/dist/caches.js

@@ -1,6 +1,6 @@
+import { cancelRender, Internals } from 'remotion';
 import { makeAudioManager } from './audio-extraction/audio-manager';
 import { makeKeyframeManager } from './video-extraction/keyframe-manager';
-export const MAX_CACHE_SIZE = 1000 * 1000 * 1000; // 1GB
 // TODO: make it dependent on the fps and concurrency
 export const SAFE_BACK_WINDOW_IN_SECONDS = 1;
 export const keyframeManager = makeKeyframeManager();
@@ -13,3 +13,39 @@ export const getTotalCacheStats = async () => {
         totalSize: keyframeManagerCacheStats.totalSize + audioManagerCacheStats.totalSize,
     };
 };
+const getUncachedMaxCacheSize = (logLevel) => {
+    if (window.remotion_mediaCacheSizeInBytes !== undefined &&
+        window.remotion_mediaCacheSizeInBytes !== null) {
+        if (window.remotion_mediaCacheSizeInBytes < 240 * 1024 * 1024) {
+            cancelRender(new Error(`The minimum value for the "mediaCacheSizeInBytes" prop is 240MB (${240 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
+        }
+        if (window.remotion_mediaCacheSizeInBytes > 20000 * 1024 * 1024) {
+            cancelRender(new Error(`The maximum value for the "mediaCacheSizeInBytes" prop is 20GB (${20000 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
+        }
+        Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set using "mediaCacheSizeInBytes": ${(window.remotion_mediaCacheSizeInBytes / 1024 / 1024).toFixed(1)} MB`);
+        return window.remotion_mediaCacheSizeInBytes;
+    }
+    if (window.remotion_initialMemoryAvailable !== undefined &&
+        window.remotion_initialMemoryAvailable !== null) {
+        const value = window.remotion_initialMemoryAvailable / 2;
+        if (value < 240 * 1024 * 1024) {
+            Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set based on minimum value of 240MB (which is more than half of the available system memory!)`);
+            return 240 * 1024 * 1024;
+        }
+        if (value > 20000 * 1024 * 1024) {
+            Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set based on maximum value of 20GB (which is less than half of the available system memory)`);
+            return 20000 * 1024 * 1024;
+        }
+        Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set based on available memory (50% of available memory): ${(value / 1024 / 1024).toFixed(1)} MB`);
+        return value;
+    }
+    return 1000 * 1000 * 1000; // 1GB
+};
+let cachedMaxCacheSize = null;
+export const getMaxVideoCacheSize = (logLevel) => {
+    if (cachedMaxCacheSize !== null) {
+        return cachedMaxCacheSize;
+    }
+    cachedMaxCacheSize = getUncachedMaxCacheSize(logLevel);
+    return cachedMaxCacheSize;
+};

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

@@ -56,8 +56,9 @@ export const resampleAudioData = ({ srcNumberOfChannels, sourceChannels, destina
             const c = getSourceValues(start, end, 2);
             const sl = getSourceValues(start, end, 3);
             const sr = getSourceValues(start, end, 4);
-            const l2 = l + Math.sqrt(1 / 2) * (c + sl);
-            const r2 = r + Math.sqrt(1 / 2) * (c + sr);
+            const sq = Math.sqrt(1 / 2);
+            const l2 = l + sq * (c + sl);
+            const r2 = r + sq * (c + sr);
             destination[newFrameIndex * 2 + 0] = l2;
             destination[newFrameIndex * 2 + 1] = r2;
         }