@remotion/media 4.0.413 → 4.0.415

package/dist/esm/index.mjs

@@ -2101,6 +2101,7 @@ var makeAudioCache = () => {
 
 // src/audio-extraction/audio-iterator.ts
 var extraThreshold = 1.5;
+var safetyOutOfOrderThreshold = 0.2;
 var warned = {};
 var warnAboutMatroskaOnce = (src, logLevel) => {
   if (warned[src]) {
@@ -2143,7 +2144,7 @@ var makeAudioIterator2 = ({
   const getSamples = async (timestamp, durationInSeconds) => {
     lastUsed = Date.now();
     if (fullDuration !== null && timestamp > fullDuration) {
-      cache.clearBeforeThreshold(fullDuration - SAFE_WINDOW_OF_MONOTONICITY);
+      cache.clearBeforeThreshold(fullDuration - safetyOutOfOrderThreshold);
       return [];
     }
     const samples = cache.getSamples(timestamp, durationInSeconds);
@@ -2156,7 +2157,7 @@ var makeAudioIterator2 = ({
     while (true) {
       const sample = await getNextSample();
       const deleteBefore = fullDuration === null ? timestamp : Math.min(timestamp, fullDuration);
-      cache.clearBeforeThreshold(deleteBefore - SAFE_WINDOW_OF_MONOTONICITY);
+      cache.clearBeforeThreshold(deleteBefore - safetyOutOfOrderThreshold);
       if (sample === null) {
         break;
       }
@@ -2418,10 +2419,11 @@ var makeKeyframeBank = async ({
           continue;
         }
       }
-      if (frameTimestamp < timestampInSeconds) {
-        if (!frames[frameTimestamp]) {
-          continue;
-        }
+      if (!frames[frameTimestamp]) {
+        continue;
+      }
+      const { duration } = frames[frameTimestamp];
+      if (frameTimestamp + duration < timestampInSeconds) {
         deleteFrameAtTimestamp(frameTimestamp);
         deletedTimestamps.push(frameTimestamp);
       }
@@ -2451,7 +2453,7 @@ var makeKeyframeBank = async ({
     lastUsed = Date.now();
     Internals9.Log.trace({ logLevel, tag: "@remotion/media" }, `Added frame at ${frame.timestamp}sec to bank`);
   };
-  const ensureEnoughFramesForTimestamp = async (timestampInSeconds, logLevel) => {
+  const ensureEnoughFramesForTimestamp = async (timestampInSeconds, logLevel, fps) => {
     while (!hasDecodedEnoughForTimestamp(timestampInSeconds)) {
       const sample = await sampleIterator.next();
       if (sample.value) {
@@ -2463,18 +2465,18 @@ var makeKeyframeBank = async ({
       }
       deleteFramesBeforeTimestamp({
         logLevel: parentLogLevel,
-        timestampInSeconds: timestampInSeconds - SAFE_WINDOW_OF_MONOTONICITY
+        timestampInSeconds: timestampInSeconds - getSafeWindowOfMonotonicity(fps)
       });
     }
     lastUsed = Date.now();
   };
-  const getFrameFromTimestamp = async (timestampInSeconds) => {
+  const getFrameFromTimestamp = async (timestampInSeconds, fps) => {
     lastUsed = Date.now();
     let adjustedTimestamp = timestampInSeconds;
     if (hasReachedEndOfVideo && roundTo4Digits(adjustedTimestamp) > roundTo4Digits(frameTimestamps[frameTimestamps.length - 1])) {
       adjustedTimestamp = frameTimestamps[frameTimestamps.length - 1];
     }
-    await ensureEnoughFramesForTimestamp(adjustedTimestamp, parentLogLevel);
+    await ensureEnoughFramesForTimestamp(adjustedTimestamp, parentLogLevel, fps);
     for (let i = frameTimestamps.length - 1;i >= 0; i--) {
       const sample = frames[frameTimestamps[i]];
       if (!sample) {
@@ -2486,8 +2488,8 @@ var makeKeyframeBank = async ({
     }
     return frames[frameTimestamps[0]] ?? null;
   };
-  const hasTimestampInSecond = async (timestamp) => {
-    return await getFrameFromTimestamp(timestamp) !== null;
+  const hasTimestampInSecond = async (timestamp, fps) => {
+    return await getFrameFromTimestamp(timestamp, fps) !== null;
   };
   const getOpenFrameCount = () => {
     return {
@@ -2510,9 +2512,12 @@ var makeKeyframeBank = async ({
     if (frameTimestamps.length === 0) {
       return null;
     }
+    const firstTimestamp = frameTimestamps[0];
+    const lastTimestamp = frameTimestamps[frameTimestamps.length - 1];
+    const lastFrame = frames[lastTimestamp];
     return {
-      firstTimestamp: frameTimestamps[0],
-      lastTimestamp: frameTimestamps[frameTimestamps.length - 1]
+      firstTimestamp,
+      lastTimestamp: lastTimestamp + lastFrame.duration
     };
   };
   const prepareForDeletion = (logLevel, reason) => {
@@ -2553,13 +2558,13 @@ var makeKeyframeBank = async ({
     return true;
   };
   const keyframeBank = {
-    getFrameFromTimestamp: (timestamp) => {
-      queue = queue.then(() => getFrameFromTimestamp(timestamp));
+    getFrameFromTimestamp: (timestamp, fps) => {
+      queue = queue.then(() => getFrameFromTimestamp(timestamp, fps));
       return queue;
     },
     prepareForDeletion,
-    hasTimestampInSecond: (timestamp) => {
-      queue = queue.then(() => hasTimestampInSecond(timestamp));
+    hasTimestampInSecond: (timestamp, fps) => {
+      queue = queue.then(() => hasTimestampInSecond(timestamp, fps));
       return queue;
     },
     addFrame,
@@ -2673,9 +2678,10 @@ var makeKeyframeManager = () => {
   const clearKeyframeBanksBeforeTime = ({
     timestampInSeconds,
     src,
-    logLevel
+    logLevel,
+    fps
   }) => {
-    const threshold = timestampInSeconds - SAFE_WINDOW_OF_MONOTONICITY;
+    const threshold = timestampInSeconds - getSafeWindowOfMonotonicity(fps);
     if (!sources[src]) {
       return;
     }
@@ -2685,9 +2691,8 @@ var makeKeyframeManager = () => {
       if (!range) {
         continue;
       }
-      const { lastTimestamp } = range;
-      if (lastTimestamp < threshold) {
-        bank.prepareForDeletion(logLevel, "cleared before threshold");
+      if (range.lastTimestamp < threshold) {
+        bank.prepareForDeletion(logLevel, "cleared before threshold " + threshold);
         Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `[Video] Cleared frames for src ${src} from ${range.firstTimestamp}sec to ${range.lastTimestamp}sec`);
         const bankIndex = banks.indexOf(bank);
         delete sources[src][bankIndex];
@@ -2741,13 +2746,15 @@ var makeKeyframeManager = () => {
     videoSampleSink,
     src,
     logLevel,
-    maxCacheSize
+    maxCacheSize,
+    fps
   }) => {
     ensureToStayUnderMaxCacheSize(logLevel, maxCacheSize);
     clearKeyframeBanksBeforeTime({
       timestampInSeconds: timestamp,
       src,
-      logLevel
+      logLevel,
+      fps
     });
     const keyframeBank = await getKeyframeBankOrRefetch({
       timestamp,
@@ -2775,14 +2782,16 @@ var makeKeyframeManager = () => {
       videoSampleSink,
       src,
       logLevel,
-      maxCacheSize
+      maxCacheSize,
+      fps
     }) => {
       queue = queue.then(() => requestKeyframeBank({
         timestamp,
         videoSampleSink,
         src,
         logLevel,
-        maxCacheSize
+        maxCacheSize,
+        fps
       }));
       return queue;
     },
@@ -2792,7 +2801,7 @@ var makeKeyframeManager = () => {
 };
 
 // src/caches.ts
-var SAFE_WINDOW_OF_MONOTONICITY = 0.2;
+var getSafeWindowOfMonotonicity = (fps) => 0.2 * 30 / fps;
 var keyframeManager = makeKeyframeManager();
 var audioManager = makeAudioManager();
 var getTotalCacheStats = () => {
@@ -3417,7 +3426,8 @@ var extractFrameInternal = async ({
       timestamp: timeInSeconds,
       src,
       logLevel,
-      maxCacheSize
+      maxCacheSize,
+      fps
     });
     if (!keyframeBank) {
       return {
@@ -3427,7 +3437,7 @@ var extractFrameInternal = async ({
         durationInSeconds: await sink.getDuration()
       };
     }
-    const frame = await keyframeBank.getFrameFromTimestamp(timeInSeconds);
+    const frame = await keyframeBank.getFrameFromTimestamp(timeInSeconds, fps);
     const rotation = frame?.rotation ?? 0;
     return {
       type: "success",

package/dist/extract-frame-and-audio.js

@@ -0,0 +1,101 @@
+import { extractAudio } from './audio-extraction/extract-audio';
+import { isNetworkError } from './is-type-of-error';
+import { extractFrame } from './video-extraction/extract-frame';
+import { rotateFrame } from './video-extraction/rotate-frame';
+export const extractFrameAndAudio = async ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, audioStreamIndex, trimAfter, trimBefore, fps, maxCacheSize, }) => {
+    try {
+        const [frame, audio] = await Promise.all([
+            includeVideo
+                ? extractFrame({
+                    src,
+                    timeInSeconds,
+                    logLevel,
+                    loop,
+                    trimAfter,
+                    playbackRate,
+                    trimBefore,
+                    fps,
+                    maxCacheSize,
+                })
+                : null,
+            includeAudio
+                ? extractAudio({
+                    src,
+                    timeInSeconds,
+                    durationInSeconds,
+                    logLevel,
+                    loop,
+                    playbackRate,
+                    audioStreamIndex,
+                    trimAfter,
+                    fps,
+                    trimBefore,
+                    maxCacheSize,
+                })
+                : null,
+        ]);
+        if (frame?.type === 'cannot-decode') {
+            return {
+                type: 'cannot-decode',
+                durationInSeconds: frame.durationInSeconds,
+            };
+        }
+        if (frame?.type === 'unknown-container-format') {
+            return { type: 'unknown-container-format' };
+        }
+        if (frame?.type === 'cannot-decode-alpha') {
+            return {
+                type: 'cannot-decode-alpha',
+                durationInSeconds: frame.durationInSeconds,
+            };
+        }
+        if (frame?.type === 'network-error') {
+            return { type: 'network-error' };
+        }
+        if (audio === 'unknown-container-format') {
+            if (frame !== null) {
+                frame?.frame?.close();
+            }
+            return { type: 'unknown-container-format' };
+        }
+        if (audio === 'network-error') {
+            if (frame !== null) {
+                frame?.frame?.close();
+            }
+            return { type: 'network-error' };
+        }
+        if (audio === 'cannot-decode') {
+            if (frame?.type === 'success' && frame.frame !== null) {
+                frame?.frame.close();
+            }
+            return {
+                type: 'cannot-decode',
+                durationInSeconds: frame?.type === 'success' ? frame.durationInSeconds : null,
+            };
+        }
+        if (!frame?.frame) {
+            return {
+                type: 'success',
+                frame: null,
+                audio: audio?.data ?? null,
+                durationInSeconds: audio?.durationInSeconds ?? null,
+            };
+        }
+        return {
+            type: 'success',
+            frame: await rotateFrame({
+                frame: frame.frame.toVideoFrame(),
+                rotation: frame.frame.rotation,
+            }),
+            audio: audio?.data ?? null,
+            durationInSeconds: audio?.durationInSeconds ?? null,
+        };
+    }
+    catch (err) {
+        const error = err;
+        if (isNetworkError(error)) {
+            return { type: 'network-error' };
+        }
+        throw err;
+    }
+};

package/dist/get-sink.js

@@ -0,0 +1,15 @@
+import { Internals } from 'remotion';
+import { getSinks } from './video-extraction/get-frames-since-keyframe';
+export const sinkPromises = {};
+export const getSink = (src, logLevel) => {
+    let promise = sinkPromises[src];
+    if (!promise) {
+        Internals.Log.verbose({
+            logLevel,
+            tag: '@remotion/media',
+        }, `Sink for ${src} was not found, creating new sink`);
+        promise = getSinks(src);
+        sinkPromises[src] = promise;
+    }
+    return promise;
+};

package/dist/get-time-in-seconds.js

@@ -0,0 +1,40 @@
+import { Internals } from 'remotion';
+export const getTimeInSeconds = ({ loop, mediaDurationInSeconds, unloopedTimeInSeconds, src, trimAfter, trimBefore, fps, playbackRate, ifNoMediaDuration, }) => {
+    if (mediaDurationInSeconds === null && loop && ifNoMediaDuration === 'fail') {
+        throw new Error(`Could not determine duration of ${src}, but "loop" was set.`);
+    }
+    const loopDuration = loop
+        ? Internals.calculateMediaDuration({
+            trimAfter,
+            mediaDurationInFrames: mediaDurationInSeconds
+                ? mediaDurationInSeconds * fps
+                : Infinity,
+            // Playback rate was already specified before
+            playbackRate: 1,
+            trimBefore,
+        }) / fps
+        : Infinity;
+    const timeInSeconds = (unloopedTimeInSeconds * playbackRate) % loopDuration;
+    if ((trimAfter ?? null) !== null && !loop) {
+        const time = (trimAfter - (trimBefore ?? 0)) / fps;
+        if (timeInSeconds >= time) {
+            return null;
+        }
+    }
+    return timeInSeconds + (trimBefore ?? 0) / fps;
+};
+export const calculateEndTime = ({ mediaDurationInSeconds, ifNoMediaDuration, src, trimAfter, trimBefore, fps, }) => {
+    if (mediaDurationInSeconds === null && ifNoMediaDuration === 'fail') {
+        throw new Error(`Could not determine duration of ${src}, but "loop" was set.`);
+    }
+    const mediaDuration = Internals.calculateMediaDuration({
+        trimAfter,
+        mediaDurationInFrames: mediaDurationInSeconds
+            ? mediaDurationInSeconds * fps
+            : Infinity,
+        // Playback rate was already specified before
+        playbackRate: 1,
+        trimBefore,
+    }) / fps;
+    return mediaDuration + (trimBefore ?? 0) / fps;
+};

package/dist/helpers/round-to-4-digits.js

@@ -0,0 +1,4 @@
+// Round to only 4 digits, because WebM has a timescale of 1_000, e.g. framer.webm
+export const roundTo4Digits = (timestamp) => {
+    return Math.round(timestamp * 1000) / 1000;
+};

package/dist/index.js

@@ -0,0 +1,12 @@
+import { Audio } from './audio/audio';
+import { Video } from './video/video';
+/**
+ * @deprecated Now just `Audio`
+ */
+export const experimental_Audio = Audio;
+/**
+ * @deprecated Now just `Video`
+ */
+export const experimental_Video = Video;
+export { AudioForPreview } from './audio/audio-for-preview';
+export { Audio, Video };

package/dist/is-network-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility to check if error is network error
+ * @param error
+ * @returns
+ */
+export declare function isNetworkError(error: Error): boolean;

package/dist/is-network-error.js

@@ -0,0 +1,17 @@
+/**
+ * Utility to check if error is network error
+ * @param error
+ * @returns
+ */
+export function isNetworkError(error) {
+    if (
+    // Chrome
+    error.message.includes('Failed to fetch') ||
+        // Safari
+        error.message.includes('Load failed') ||
+        // Firefox
+        error.message.includes('NetworkError when attempting to fetch resource')) {
+        return true;
+    }
+    return false;
+}

package/dist/is-type-of-error.js

@@ -0,0 +1,20 @@
+/**
+ * Utility to check if error is network error
+ * @param error
+ * @returns
+ */
+export function isNetworkError(error) {
+    if (
+    // Chrome
+    error.message.includes('Failed to fetch') ||
+        // Safari
+        error.message.includes('Load failed') ||
+        // Firefox
+        error.message.includes('NetworkError when attempting to fetch resource')) {
+        return true;
+    }
+    return false;
+}
+export function isUnsupportedConfigurationError(error) {
+    return error.message.includes('Unsupported configuration');
+}

package/dist/looped-frame.js

@@ -0,0 +1,10 @@
+export const frameForVolumeProp = ({ behavior, loop, assetDurationInSeconds, fps, frame, startsAt, }) => {
+    if (!loop) {
+        return frame + startsAt;
+    }
+    if (behavior === 'extend') {
+        return frame + startsAt;
+    }
+    const assetDurationInFrames = Math.floor(assetDurationInSeconds * fps) - startsAt;
+    return (frame % assetDurationInFrames) + startsAt;
+};