@remotion/media 4.0.382 → 4.0.383

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

@@ -4,6 +4,7 @@ import { convertAudioData, fixFloatingPoint, } from '../convert-audiodata/conver
 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';
+import { isNetworkError, isUnsupportedConfigurationError, } from '../is-type-of-error';
 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;
@@ -47,70 +48,82 @@ const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds,
         maxCacheSize,
     });
     const durationInSeconds = durationNotYetApplyingPlaybackRate * playbackRate;
-    const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
-    audioManager.logOpenFrames();
-    const audioDataArray = [];
-    for (let i = 0; i < samples.length; i++) {
-        const sample = samples[i];
-        // Less than 1 sample would be included - we did not need it after all!
-        if (Math.abs(sample.timestamp - (timeInSeconds + durationInSeconds)) *
-            sample.sampleRate <
-            1) {
-            continue;
-        }
-        // Less than 1 sample would be included - we did not need it after all!
-        if (sample.timestamp + sample.duration <= timeInSeconds) {
-            continue;
-        }
-        const isFirstSample = i === 0;
-        const isLastSample = i === samples.length - 1;
-        const audioDataRaw = sample.toAudioData();
-        // amount of samples to shave from start and end
-        let trimStartInSeconds = 0;
-        let trimEndInSeconds = 0;
-        let leadingSilence = null;
-        if (isFirstSample) {
-            trimStartInSeconds = fixFloatingPoint(timeInSeconds - sample.timestamp);
-            if (trimStartInSeconds < 0) {
-                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;
+    try {
+        const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
+        audioManager.logOpenFrames();
+        const audioDataArray = [];
+        for (let i = 0; i < samples.length; i++) {
+            const sample = samples[i];
+            // Less than 1 sample would be included - we did not need it after all!
+            if (Math.abs(sample.timestamp - (timeInSeconds + durationInSeconds)) *
+                sample.sampleRate <
+                1) {
+                continue;
+            }
+            // Less than 1 sample would be included - we did not need it after all!
+            if (sample.timestamp + sample.duration <= timeInSeconds) {
+                continue;
+            }
+            const isFirstSample = i === 0;
+            const isLastSample = i === samples.length - 1;
+            const audioDataRaw = sample.toAudioData();
+            // amount of samples to shave from start and end
+            let trimStartInSeconds = 0;
+            let trimEndInSeconds = 0;
+            let leadingSilence = null;
+            if (isFirstSample) {
+                trimStartInSeconds = fixFloatingPoint(timeInSeconds - sample.timestamp);
+                if (trimStartInSeconds < 0) {
+                    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) {
+                trimEndInSeconds =
+                    // clamp to 0 in case the audio ends early
+                    Math.max(0, sample.timestamp +
+                        sample.duration -
+                        (timeInSeconds + durationInSeconds));
             }
+            const audioData = convertAudioData({
+                audioData: audioDataRaw,
+                trimStartInSeconds,
+                trimEndInSeconds,
+                playbackRate,
+                audioDataTimestamp: sample.timestamp,
+                isLast: isLastSample,
+            });
+            audioDataRaw.close();
+            if (audioData.numberOfFrames === 0) {
+                continue;
+            }
+            if (leadingSilence) {
+                audioDataArray.push(leadingSilence);
+            }
+            audioDataArray.push(audioData);
         }
-        if (isLastSample) {
-            trimEndInSeconds =
-                // clamp to 0 in case the audio ends early
-                Math.max(0, sample.timestamp +
-                    sample.duration -
-                    (timeInSeconds + durationInSeconds));
+        if (audioDataArray.length === 0) {
+            return { data: null, durationInSeconds: mediaDurationInSeconds };
         }
-        const audioData = convertAudioData({
-            audioData: audioDataRaw,
-            trimStartInSeconds,
-            trimEndInSeconds,
-            playbackRate,
-            audioDataTimestamp: sample.timestamp,
-            isLast: isLastSample,
-        });
-        audioDataRaw.close();
-        if (audioData.numberOfFrames === 0) {
-            continue;
+        const combined = combineAudioDataAndClosePrevious(audioDataArray);
+        return { data: combined, durationInSeconds: mediaDurationInSeconds };
+    }
+    catch (err) {
+        const error = err;
+        if (isNetworkError(error)) {
+            return 'network-error';
         }
-        if (leadingSilence) {
-            audioDataArray.push(leadingSilence);
+        if (isUnsupportedConfigurationError(error)) {
+            return 'cannot-decode';
         }
-        audioDataArray.push(audioData);
-    }
-    if (audioDataArray.length === 0) {
-        return { data: null, durationInSeconds: mediaDurationInSeconds };
+        throw err;
     }
-    const combined = combineAudioDataAndClosePrevious(audioDataArray);
-    return { data: combined, durationInSeconds: mediaDurationInSeconds };
 };
 let queue = Promise.resolve(undefined);
 export const extractAudio = (params) => {

package/dist/esm/index.mjs

@@ -538,13 +538,16 @@ var drawPreviewOverlay = ({
   }
 };
 
-// src/is-network-error.ts
+// src/is-type-of-error.ts
 function isNetworkError(error) {
   if (error.message.includes("Failed to fetch") || error.message.includes("Load failed") || error.message.includes("NetworkError when attempting to fetch resource")) {
     return true;
   }
   return false;
 }
+function isUnsupportedConfigurationError(error) {
+  return error.message.includes("Unsupported configuration");
+}
 
 // src/nonce-manager.ts
 var makeNonceManager = () => {
@@ -2902,61 +2905,72 @@ var extractAudioInternal = async ({
     maxCacheSize
   });
   const durationInSeconds = durationNotYetApplyingPlaybackRate * playbackRate;
-  const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
-  audioManager.logOpenFrames();
-  const audioDataArray = [];
-  for (let i = 0;i < samples.length; i++) {
-    const sample = samples[i];
-    if (Math.abs(sample.timestamp - (timeInSeconds + durationInSeconds)) * sample.sampleRate < 1) {
-      continue;
-    }
-    if (sample.timestamp + sample.duration <= timeInSeconds) {
-      continue;
-    }
-    const isFirstSample = i === 0;
-    const isLastSample = i === samples.length - 1;
-    const audioDataRaw = sample.toAudioData();
-    let trimStartInSeconds = 0;
-    let trimEndInSeconds = 0;
-    let leadingSilence = null;
-    if (isFirstSample) {
-      trimStartInSeconds = fixFloatingPoint2(timeInSeconds - sample.timestamp);
-      if (trimStartInSeconds < 0) {
-        const silenceFrames = Math.ceil(fixFloatingPoint2(-trimStartInSeconds * TARGET_SAMPLE_RATE));
-        leadingSilence = {
-          data: new Int16Array(silenceFrames * TARGET_NUMBER_OF_CHANNELS),
-          numberOfFrames: silenceFrames,
-          timestamp: timeInSeconds * 1e6,
-          durationInMicroSeconds: silenceFrames / TARGET_SAMPLE_RATE * 1e6
-        };
-        trimStartInSeconds = 0;
+  try {
+    const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
+    audioManager.logOpenFrames();
+    const audioDataArray = [];
+    for (let i = 0;i < samples.length; i++) {
+      const sample = samples[i];
+      if (Math.abs(sample.timestamp - (timeInSeconds + durationInSeconds)) * sample.sampleRate < 1) {
+        continue;
       }
+      if (sample.timestamp + sample.duration <= timeInSeconds) {
+        continue;
+      }
+      const isFirstSample = i === 0;
+      const isLastSample = i === samples.length - 1;
+      const audioDataRaw = sample.toAudioData();
+      let trimStartInSeconds = 0;
+      let trimEndInSeconds = 0;
+      let leadingSilence = null;
+      if (isFirstSample) {
+        trimStartInSeconds = fixFloatingPoint2(timeInSeconds - sample.timestamp);
+        if (trimStartInSeconds < 0) {
+          const silenceFrames = Math.ceil(fixFloatingPoint2(-trimStartInSeconds * TARGET_SAMPLE_RATE));
+          leadingSilence = {
+            data: new Int16Array(silenceFrames * TARGET_NUMBER_OF_CHANNELS),
+            numberOfFrames: silenceFrames,
+            timestamp: timeInSeconds * 1e6,
+            durationInMicroSeconds: silenceFrames / TARGET_SAMPLE_RATE * 1e6
+          };
+          trimStartInSeconds = 0;
+        }
+      }
+      if (isLastSample) {
+        trimEndInSeconds = Math.max(0, sample.timestamp + sample.duration - (timeInSeconds + durationInSeconds));
+      }
+      const audioData = convertAudioData({
+        audioData: audioDataRaw,
+        trimStartInSeconds,
+        trimEndInSeconds,
+        playbackRate,
+        audioDataTimestamp: sample.timestamp,
+        isLast: isLastSample
+      });
+      audioDataRaw.close();
+      if (audioData.numberOfFrames === 0) {
+        continue;
+      }
+      if (leadingSilence) {
+        audioDataArray.push(leadingSilence);
+      }
+      audioDataArray.push(audioData);
     }
-    if (isLastSample) {
-      trimEndInSeconds = Math.max(0, sample.timestamp + sample.duration - (timeInSeconds + durationInSeconds));
+    if (audioDataArray.length === 0) {
+      return { data: null, durationInSeconds: mediaDurationInSeconds };
     }
-    const audioData = convertAudioData({
-      audioData: audioDataRaw,
-      trimStartInSeconds,
-      trimEndInSeconds,
-      playbackRate,
-      audioDataTimestamp: sample.timestamp,
-      isLast: isLastSample
-    });
-    audioDataRaw.close();
-    if (audioData.numberOfFrames === 0) {
-      continue;
+    const combined = combineAudioDataAndClosePrevious(audioDataArray);
+    return { data: combined, durationInSeconds: mediaDurationInSeconds };
+  } catch (err) {
+    const error = err;
+    if (isNetworkError(error)) {
+      return "network-error";
     }
-    if (leadingSilence) {
-      audioDataArray.push(leadingSilence);
+    if (isUnsupportedConfigurationError(error)) {
+      return "cannot-decode";
     }
-    audioDataArray.push(audioData);
-  }
-  if (audioDataArray.length === 0) {
-    return { data: null, durationInSeconds: mediaDurationInSeconds };
+    throw err;
   }
-  const combined = combineAudioDataAndClosePrevious(audioDataArray);
-  return { data: combined, durationInSeconds: mediaDurationInSeconds };
 };
 var queue = Promise.resolve(undefined);
 var extractAudio = (params) => {
@@ -4115,7 +4129,7 @@ var VideoForRendering = ({
           cancelRender3(new Error(`Cannot decode ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
         }
         if (window.remotion_isMainTab) {
-          Internals16.Log.info({ logLevel, tag: "@remotion/media" }, `Cannot decode ${src}, falling back to <OffthreadVideo>`);
+          Internals16.Log.warn({ logLevel, tag: "@remotion/media" }, `Cannot decode ${src}, falling back to <OffthreadVideo>`);
         }
         setReplaceWithOffthreadVideo({
           durationInSeconds: result.durationInSeconds

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

@@ -1,5 +1,5 @@
 import { extractAudio } from './audio-extraction/extract-audio';
-import { isNetworkError } from './is-network-error';
+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, }) => {

package/dist/is-type-of-error.d.ts

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

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/media-player.js

@@ -4,7 +4,7 @@ import { audioIteratorManager, } from './audio-iterator-manager';
 import { calculatePlaybackTime } from './calculate-playbacktime';
 import { drawPreviewOverlay } from './debug-overlay/preview-overlay';
 import { getTimeInSeconds } from './get-time-in-seconds';
-import { isNetworkError } from './is-network-error';
+import { isNetworkError } from './is-type-of-error';
 import { makeNonceManager } from './nonce-manager';
 import { videoIteratorManager } from './video-iterator-manager';
 export class MediaPlayer {

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

@@ -92,7 +92,7 @@ export const VideoForRendering = ({ volume: volumeProp, playbackRate, src, muted
                     cancelRender(new Error(`Cannot decode ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
                 }
                 if (window.remotion_isMainTab) {
-                    Internals.Log.info({ logLevel, tag: '@remotion/media' }, `Cannot decode ${src}, falling back to <OffthreadVideo>`);
+                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Cannot decode ${src}, falling back to <OffthreadVideo>`);
                 }
                 setReplaceWithOffthreadVideo({
                     durationInSeconds: result.durationInSeconds,

package/dist/video-extraction/get-frames-since-keyframe.js

@@ -1,5 +1,5 @@
 import { ALL_FORMATS, AudioSampleSink, EncodedPacketSink, Input, MATROSKA, UrlSource, VideoSampleSink, WEBM, } from 'mediabunny';
-import { isNetworkError } from '../is-network-error';
+import { isNetworkError } from '../is-type-of-error';
 import { makeKeyframeBank } from './keyframe-bank';
 import { rememberActualMatroskaTimestamps } from './remember-actual-matroska-timestamps';
 const getRetryDelay = (() => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.382",
+	"version": "4.0.383",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -22,14 +22,14 @@
 	},
 	"dependencies": {
 		"mediabunny": "1.25.3",
-		"remotion": "4.0.382"
+		"remotion": "4.0.383"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.382",
+		"@remotion/eslint-config-internal": "4.0.383",
 		"@vitest/browser-webdriverio": "4.0.7",
 		"eslint": "9.19.0",
 		"react": "19.2.1",