@remotion/media 4.0.401 → 4.0.403

package/dist/esm/index.mjs

@@ -605,12 +605,12 @@ var drawPreviewOverlay = ({
     `Audio iterators created: ${audioIteratorManager2?.getAudioIteratorsCreated()}`,
     `Frames rendered: ${videoIteratorManager?.getFramesRendered()}`,
     `Audio context state: ${audioContextState}`,
-    `Audio time: ${(audioTime - audioSyncAnchor).toFixed(3)}s`
-  ];
+    audioTime ? `Audio time: ${(audioTime - audioSyncAnchor).toFixed(3)}s` : null
+  ].filter(Boolean);
   if (audioIteratorManager2) {
     const queuedPeriod = audioIteratorManager2.getAudioBufferIterator()?.getQueuedPeriod();
     const numberOfChunksAfterResuming = audioIteratorManager2?.getAudioBufferIterator()?.getNumberOfChunksAfterResuming();
-    if (queuedPeriod) {
+    if (queuedPeriod && audioTime) {
       lines.push(`Audio queued until: ${(queuedPeriod.until - (audioTime - audioSyncAnchor)).toFixed(3)}s`);
     } else if (numberOfChunksAfterResuming) {
       lines.push(`Audio chunks for after resuming: ${numberOfChunksAfterResuming}`);
@@ -946,7 +946,7 @@ class MediaPlayer {
   }) {
     this.canvas = canvas ?? null;
     this.src = src;
-    this.logLevel = logLevel ?? window.remotion_logLevel;
+    this.logLevel = logLevel;
     this.sharedAudioContext = sharedAudioContext;
     this.playbackRate = playbackRate;
     this.globalPlaybackRate = globalPlaybackRate;
@@ -1070,7 +1070,7 @@ class MediaPlayer {
         throw new Error(`should have asserted that the time is not null`);
       }
       this.setPlaybackTime(startTime, this.playbackRate * this.globalPlaybackRate);
-      if (audioTrack) {
+      if (audioTrack && this.sharedAudioContext) {
         this.audioIteratorManager = audioIteratorManager({
           audioTrack,
           delayPlaybackHandleIfNotPremounting: this.delayPlaybackHandleIfNotPremounting,
@@ -1136,16 +1136,13 @@ class MediaPlayer {
     if (nonce.isStale()) {
       return;
     }
-    const currentPlaybackTime = this.getPlaybackTime();
-    if (currentPlaybackTime === newTime) {
-      return;
-    }
+    const shouldSeekAudio = this.audioIteratorManager && this.sharedAudioContext && this.getAudioPlaybackTime() !== newTime;
     await Promise.all([
       this.videoIteratorManager?.seek({
         newTime,
         nonce
       }),
-      this.audioIteratorManager?.seek({
+      shouldSeekAudio ? this.audioIteratorManager?.seek({
         newTime,
         nonce,
         fps: this.fps,
@@ -1153,7 +1150,7 @@ class MediaPlayer {
         getIsPlaying: () => this.playing,
         scheduleAudioNode: this.scheduleAudioNode,
         bufferState: this.bufferState
-      })
+      }) : null
     ]);
   }
   async play(time) {
@@ -1182,7 +1179,7 @@ class MediaPlayer {
         scheduleAudioNode: this.scheduleAudioNode
       });
     }
-    if (this.sharedAudioContext.state === "suspended") {
+    if (this.sharedAudioContext && this.sharedAudioContext.state === "suspended") {
       await this.sharedAudioContext.resume();
     }
     this.drawDebugOverlay();
@@ -1247,11 +1244,14 @@ class MediaPlayer {
   setDebugOverlay(debugOverlay) {
     this.debugOverlay = debugOverlay;
   }
-  updateAfterPlaybackRateChange() {
+  updateAudioTimeAfterPlaybackRateChange() {
     if (!this.audioIteratorManager) {
       return;
     }
-    this.setPlaybackTime(this.getPlaybackTime(), this.playbackRate * this.globalPlaybackRate);
+    if (!this.sharedAudioContext) {
+      return;
+    }
+    this.setPlaybackTime(this.getAudioPlaybackTime(), this.playbackRate * this.globalPlaybackRate);
     const iterator = this.audioIteratorManager.getAudioBufferIterator();
     if (!iterator) {
       return;
@@ -1266,11 +1266,11 @@ class MediaPlayer {
   }
   setPlaybackRate(rate) {
     this.playbackRate = rate;
-    this.updateAfterPlaybackRateChange();
+    this.updateAudioTimeAfterPlaybackRateChange();
   }
   setGlobalPlaybackRate(rate) {
     this.globalPlaybackRate = rate;
-    this.updateAfterPlaybackRateChange();
+    this.updateAudioTimeAfterPlaybackRateChange();
   }
   setFps(fps) {
     this.fps = fps;
@@ -1296,16 +1296,22 @@ class MediaPlayer {
     this.input.dispose();
   }
   scheduleAudioNode = (node, mediaTimestamp) => {
-    const currentTime = this.getPlaybackTime();
+    const currentTime = this.getAudioPlaybackTime();
     const delayWithoutPlaybackRate = mediaTimestamp - currentTime;
     const delay = delayWithoutPlaybackRate / (this.playbackRate * this.globalPlaybackRate);
+    if (!this.sharedAudioContext) {
+      throw new Error("Shared audio context not found");
+    }
     if (delay >= 0) {
       node.start(this.sharedAudioContext.currentTime + delay);
     } else {
       node.start(this.sharedAudioContext.currentTime, -delay);
     }
   };
-  getPlaybackTime() {
+  getAudioPlaybackTime() {
+    if (!this.sharedAudioContext) {
+      throw new Error("Shared audio context not found");
+    }
     return calculatePlaybackTime({
       audioSyncAnchor: this.audioSyncAnchor,
       currentTime: this.sharedAudioContext.currentTime,
@@ -1313,6 +1319,9 @@ class MediaPlayer {
     });
   }
   setPlaybackTime(time, playbackRate) {
+    if (!this.sharedAudioContext) {
+      return;
+    }
     this.audioSyncAnchor = this.sharedAudioContext.currentTime - time / playbackRate;
   }
   setVideoFrameCallback(callback) {
@@ -1324,8 +1333,8 @@ class MediaPlayer {
     if (this.context && this.canvas) {
       drawPreviewOverlay({
         context: this.context,
-        audioTime: this.sharedAudioContext.currentTime,
-        audioContextState: this.sharedAudioContext.state,
+        audioTime: this.sharedAudioContext?.currentTime ?? null,
+        audioContextState: this.sharedAudioContext?.state ?? null,
         audioSyncAnchor: this.audioSyncAnchor,
         audioIteratorManager: this.audioIteratorManager,
         playing: this.playing,
@@ -1821,6 +1830,7 @@ var AudioForPreview = ({
   fallbackHtml5AudioProps
 }) => {
   const preloadedSrc = usePreload(src);
+  const defaultLogLevel = Internals6.useLogLevel();
   const frame = useCurrentFrame2();
   const videoConfig = useVideoConfig2();
   const currentTime = frame / videoConfig.fps;
@@ -1852,7 +1862,7 @@ var AudioForPreview = ({
     audioStreamIndex: audioStreamIndex ?? 0,
     src: preloadedSrc,
     playbackRate: playbackRate ?? 1,
-    logLevel: logLevel ?? (typeof window !== "undefined" ? window.remotion_logLevel ?? "info" : "info"),
+    logLevel: logLevel ?? defaultLogLevel,
     muted: muted ?? false,
     volume: volume ?? 1,
     loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? "repeat",
@@ -2002,7 +2012,7 @@ var makeAudioIterator2 = ({
   const getSamples = async (timestamp, durationInSeconds) => {
     lastUsed = Date.now();
     if (fullDuration !== null && timestamp > fullDuration) {
-      cache.clearBeforeThreshold(fullDuration - SAFE_BACK_WINDOW_IN_SECONDS);
+      cache.clearBeforeThreshold(fullDuration - SAFE_WINDOW_OF_MONOTONICITY);
       return [];
     }
     const samples = cache.getSamples(timestamp, durationInSeconds);
@@ -2015,7 +2025,7 @@ var makeAudioIterator2 = ({
     while (true) {
       const sample = await getNextSample();
       const deleteBefore = fullDuration === null ? timestamp : Math.min(timestamp, fullDuration);
-      cache.clearBeforeThreshold(deleteBefore - SAFE_BACK_WINDOW_IN_SECONDS);
+      cache.clearBeforeThreshold(deleteBefore - SAFE_WINDOW_OF_MONOTONICITY);
       if (sample === null) {
         break;
       }
@@ -2145,8 +2155,14 @@ var makeAudioManager = () => {
     logLevel,
     maxCacheSize
   }) => {
-    while ((await getTotalCacheStats()).totalSize > maxCacheSize) {
+    let attempts = 0;
+    const maxAttempts = 3;
+    while ((await getTotalCacheStats()).totalSize > maxCacheSize && attempts < maxAttempts) {
       deleteOldestIterator();
+      attempts++;
+    }
+    if ((await getTotalCacheStats()).totalSize > maxCacheSize && attempts >= maxAttempts) {
+      Internals8.Log.warn({ logLevel, tag: "@remotion/media" }, `Audio cache: Exceeded max cache size after ${maxAttempts} attempts. Still ${(await getTotalCacheStats()).totalSize} bytes used, target was ${maxCacheSize} bytes.`);
     }
     for (const iterator of iterators) {
       if (iterator.src === src && await iterator.waitForCompletion() && iterator.canSatisfyRequestedTime(timeInSeconds)) {
@@ -2217,21 +2233,6 @@ var makeAudioManager = () => {
 // src/video-extraction/keyframe-manager.ts
 import { Internals as Internals10 } from "remotion";
 
-// src/browser-can-use-webgl2.ts
-var browserCanUseWebGl2 = null;
-var browserCanUseWebGl2Uncached = () => {
-  const canvas = new OffscreenCanvas(1, 1);
-  const context = canvas.getContext("webgl2");
-  return context !== null;
-};
-var canBrowserUseWebGl2 = () => {
-  if (browserCanUseWebGl2 !== null) {
-    return browserCanUseWebGl2;
-  }
-  browserCanUseWebGl2 = browserCanUseWebGl2Uncached();
-  return browserCanUseWebGl2;
-};
-
 // src/render-timestamp-range.ts
 var renderTimestampRange = (timestamps) => {
   if (timestamps.length === 0) {
@@ -2243,18 +2244,6 @@ var renderTimestampRange = (timestamps) => {
   return `${timestamps[0].toFixed(3)}...${timestamps[timestamps.length - 1].toFixed(3)}`;
 };
 
-// src/video-extraction/get-frames-since-keyframe.ts
-import {
-  ALL_FORMATS as ALL_FORMATS2,
-  AudioSampleSink,
-  EncodedPacketSink,
-  Input as Input2,
-  MATROSKA,
-  UrlSource as UrlSource2,
-  VideoSampleSink,
-  WEBM
-} from "mediabunny";
-
 // src/video-extraction/keyframe-bank.ts
 import { Internals as Internals9 } from "remotion";
 
@@ -2267,36 +2256,42 @@ var getAllocationSize = (sample) => {
 };
 
 // src/video-extraction/keyframe-bank.ts
-var makeKeyframeBank = ({
-  startTimestampInSeconds,
-  endTimestampInSeconds,
-  sampleIterator,
+var BIGGEST_ALLOWED_JUMP_FORWARD_SECONDS = 3;
+var makeKeyframeBank = async ({
   logLevel: parentLogLevel,
-  src
+  src,
+  videoSampleSink,
+  requestedTimestamp
 }) => {
-  Internals9.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
+  const sampleIterator = videoSampleSink.samples(roundTo4Digits(requestedTimestamp));
   const frames = {};
   const frameTimestamps = [];
+  let hasReachedEndOfVideo = false;
   let lastUsed = Date.now();
   let allocationSize = 0;
+  const deleteFrameAtTimestamp = (timestamp) => {
+    allocationSize -= getAllocationSize(frames[timestamp]);
+    frameTimestamps.splice(frameTimestamps.indexOf(timestamp), 1);
+    frames[timestamp].close();
+    delete frames[timestamp];
+  };
   const deleteFramesBeforeTimestamp = ({
     logLevel,
     timestampInSeconds
   }) => {
     const deletedTimestamps = [];
     for (const frameTimestamp of frameTimestamps.slice()) {
-      const isLast = frameTimestamp === frameTimestamps[frameTimestamps.length - 1];
-      if (isLast) {
-        continue;
+      if (hasReachedEndOfVideo) {
+        const isLast = frameTimestamp === frameTimestamps[frameTimestamps.length - 1];
+        if (isLast) {
+          continue;
+        }
       }
       if (frameTimestamp < timestampInSeconds) {
         if (!frames[frameTimestamp]) {
           continue;
         }
-        allocationSize -= getAllocationSize(frames[frameTimestamp]);
-        frameTimestamps.splice(frameTimestamps.indexOf(frameTimestamp), 1);
-        frames[frameTimestamp].close();
-        delete frames[frameTimestamp];
+        deleteFrameAtTimestamp(frameTimestamp);
         deletedTimestamps.push(frameTimestamp);
       }
     }
@@ -2313,32 +2308,31 @@ var makeKeyframeBank = ({
     if (!lastFrame) {
       return true;
     }
-    return roundTo4Digits(lastFrame.timestamp + lastFrame.duration) > roundTo4Digits(timestamp) + 0.001;
+    return roundTo4Digits(lastFrame.timestamp + lastFrame.duration) > roundTo4Digits(timestamp) + SAFE_WINDOW_OF_MONOTONICITY;
   };
-  const addFrame = (frame) => {
+  const addFrame = (frame, logLevel) => {
     if (frames[frame.timestamp]) {
-      allocationSize -= getAllocationSize(frames[frame.timestamp]);
-      frameTimestamps.splice(frameTimestamps.indexOf(frame.timestamp), 1);
-      frames[frame.timestamp].close();
-      delete frames[frame.timestamp];
+      deleteFrameAtTimestamp(frame.timestamp);
     }
     frames[frame.timestamp] = frame;
     frameTimestamps.push(frame.timestamp);
     allocationSize += getAllocationSize(frame);
     lastUsed = Date.now();
+    Internals9.Log.trace({ logLevel, tag: "@remotion/media" }, `Added frame at ${frame.timestamp}sec to bank`);
   };
-  const ensureEnoughFramesForTimestamp = async (timestampInSeconds) => {
+  const ensureEnoughFramesForTimestamp = async (timestampInSeconds, logLevel) => {
     while (!hasDecodedEnoughForTimestamp(timestampInSeconds)) {
       const sample = await sampleIterator.next();
       if (sample.value) {
-        addFrame(sample.value);
+        addFrame(sample.value, logLevel);
       }
       if (sample.done) {
+        hasReachedEndOfVideo = true;
         break;
       }
       deleteFramesBeforeTimestamp({
         logLevel: parentLogLevel,
-        timestampInSeconds: timestampInSeconds - SAFE_BACK_WINDOW_IN_SECONDS
+        timestampInSeconds: timestampInSeconds - SAFE_WINDOW_OF_MONOTONICITY
       });
     }
     lastUsed = Date.now();
@@ -2346,13 +2340,10 @@ var makeKeyframeBank = ({
   const getFrameFromTimestamp = async (timestampInSeconds) => {
     lastUsed = Date.now();
     let adjustedTimestamp = timestampInSeconds;
-    if (roundTo4Digits(timestampInSeconds) < roundTo4Digits(startTimestampInSeconds)) {
-      adjustedTimestamp = startTimestampInSeconds;
+    if (hasReachedEndOfVideo && roundTo4Digits(adjustedTimestamp) > roundTo4Digits(frameTimestamps[frameTimestamps.length - 1])) {
+      adjustedTimestamp = frameTimestamps[frameTimestamps.length - 1];
     }
-    if (roundTo4Digits(adjustedTimestamp) > roundTo4Digits(endTimestampInSeconds)) {
-      adjustedTimestamp = endTimestampInSeconds;
-    }
-    await ensureEnoughFramesForTimestamp(adjustedTimestamp);
+    await ensureEnoughFramesForTimestamp(adjustedTimestamp, parentLogLevel);
     for (let i = frameTimestamps.length - 1;i >= 0; i--) {
       const sample = frames[frameTimestamps[i]];
       if (!sample) {
@@ -2362,32 +2353,11 @@ var makeKeyframeBank = ({
         return sample;
       }
     }
-    return null;
+    return frames[frameTimestamps[0]] ?? null;
   };
   const hasTimestampInSecond = async (timestamp) => {
     return await getFrameFromTimestamp(timestamp) !== null;
   };
-  const prepareForDeletion = (logLevel) => {
-    Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Preparing for deletion of keyframe bank from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
-    sampleIterator.return().then((result) => {
-      if (result.value) {
-        result.value.close();
-      }
-      return null;
-    });
-    let framesDeleted = 0;
-    for (const frameTimestamp of frameTimestamps) {
-      if (!frames[frameTimestamp]) {
-        continue;
-      }
-      allocationSize -= getAllocationSize(frames[frameTimestamp]);
-      frames[frameTimestamp].close();
-      delete frames[frameTimestamp];
-      framesDeleted++;
-    }
-    frameTimestamps.length = 0;
-    return { framesDeleted };
-  };
   const getOpenFrameCount = () => {
     return {
       size: allocationSize,
@@ -2398,173 +2368,91 @@ var makeKeyframeBank = ({
     return lastUsed;
   };
   let queue = Promise.resolve(undefined);
-  const keyframeBank = {
-    startTimestampInSeconds,
-    endTimestampInSeconds,
-    getFrameFromTimestamp: (timestamp) => {
-      queue = queue.then(() => getFrameFromTimestamp(timestamp));
-      return queue;
-    },
-    prepareForDeletion,
-    hasTimestampInSecond,
-    addFrame,
-    deleteFramesBeforeTimestamp,
-    src,
-    getOpenFrameCount,
-    getLastUsed
-  };
-  return keyframeBank;
-};
-
-// src/video-extraction/remember-actual-matroska-timestamps.ts
-var rememberActualMatroskaTimestamps = (isMatroska) => {
-  const observations = [];
-  const observeTimestamp = (startTime) => {
-    if (!isMatroska) {
-      return;
-    }
-    observations.push(startTime);
-  };
-  const getRealTimestamp = (observedTimestamp) => {
-    if (!isMatroska) {
-      return observedTimestamp;
-    }
-    return observations.find((observation) => Math.abs(observedTimestamp - observation) < 0.001) ?? null;
-  };
-  return {
-    observeTimestamp,
-    getRealTimestamp
-  };
-};
-
-// src/video-extraction/get-frames-since-keyframe.ts
-var getRetryDelay = () => {
-  return null;
-};
-var getFormatOrNullOrNetworkError = async (input) => {
-  try {
-    return await input.getFormat();
-  } catch (err) {
-    if (isNetworkError(err)) {
-      return "network-error";
-    }
-    return null;
+  const firstFrame = await sampleIterator.next();
+  if (!firstFrame.value) {
+    throw new Error("No first frame found");
   }
-};
-var getSinks = async (src) => {
-  const input = new Input2({
-    formats: ALL_FORMATS2,
-    source: new UrlSource2(src, {
-      getRetryDelay
-    })
-  });
-  const format = await getFormatOrNullOrNetworkError(input);
-  const isMatroska = format === MATROSKA || format === WEBM;
-  const getVideoSinks = async () => {
-    if (format === "network-error") {
-      return "network-error";
-    }
-    if (format === null) {
-      return "unknown-container-format";
-    }
-    const videoTrack = await input.getPrimaryVideoTrack();
-    if (!videoTrack) {
-      return "no-video-track";
-    }
-    const canDecode = await videoTrack.canDecode();
-    if (!canDecode) {
-      return "cannot-decode";
+  const startTimestampInSeconds = firstFrame.value.timestamp;
+  Internals9.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec`);
+  addFrame(firstFrame.value, parentLogLevel);
+  const getRangeOfTimestamps = () => {
+    if (frameTimestamps.length === 0) {
+      return null;
     }
     return {
-      sampleSink: new VideoSampleSink(videoTrack),
-      packetSink: new EncodedPacketSink(videoTrack)
+      firstTimestamp: frameTimestamps[0],
+      lastTimestamp: frameTimestamps[frameTimestamps.length - 1]
     };
   };
-  let videoSinksPromise = null;
-  const getVideoSinksPromise = () => {
-    if (videoSinksPromise) {
-      return videoSinksPromise;
+  const prepareForDeletion = (logLevel, reason) => {
+    const range = getRangeOfTimestamps();
+    if (range) {
+      Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Preparing for deletion (${reason}) of keyframe bank from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec`);
     }
-    videoSinksPromise = getVideoSinks();
-    return videoSinksPromise;
-  };
-  const audioSinksPromise = {};
-  const getAudioSinks = async (index) => {
-    if (format === null) {
-      return "unknown-container-format";
+    let framesDeleted = 0;
+    for (const frameTimestamp of frameTimestamps.slice()) {
+      if (!frames[frameTimestamp]) {
+        continue;
+      }
+      deleteFrameAtTimestamp(frameTimestamp);
+      framesDeleted++;
     }
-    if (format === "network-error") {
-      return "network-error";
+    sampleIterator.return();
+    frameTimestamps.length = 0;
+    return { framesDeleted };
+  };
+  const canSatisfyTimestamp = (timestamp) => {
+    if (frameTimestamps.length === 0) {
+      return false;
     }
-    const audioTracks = await input.getAudioTracks();
-    const audioTrack = audioTracks[index];
-    if (!audioTrack) {
-      return "no-audio-track";
+    const roundedTimestamp = roundTo4Digits(timestamp);
+    const firstFrameTimestamp = roundTo4Digits(frameTimestamps[0]);
+    const lastFrameTimestamp = roundTo4Digits(frameTimestamps[frameTimestamps.length - 1]);
+    if (hasReachedEndOfVideo && roundedTimestamp > lastFrameTimestamp) {
+      return true;
     }
-    const canDecode = await audioTrack.canDecode();
-    if (!canDecode) {
-      return "cannot-decode-audio";
+    if (roundedTimestamp < firstFrameTimestamp) {
+      return false;
     }
-    return {
-      sampleSink: new AudioSampleSink(audioTrack)
-    };
-  };
-  const getAudioSinksPromise = (index) => {
-    if (audioSinksPromise[index]) {
-      return audioSinksPromise[index];
+    if (roundedTimestamp - BIGGEST_ALLOWED_JUMP_FORWARD_SECONDS > lastFrameTimestamp) {
+      return false;
     }
-    audioSinksPromise[index] = getAudioSinks(index);
-    return audioSinksPromise[index];
+    return true;
   };
-  return {
-    getVideo: () => getVideoSinksPromise(),
-    getAudio: (index) => getAudioSinksPromise(index),
-    actualMatroskaTimestamps: rememberActualMatroskaTimestamps(isMatroska),
-    isMatroska,
-    getDuration: () => {
-      return input.computeDuration();
-    }
+  const keyframeBank = {
+    getFrameFromTimestamp: (timestamp) => {
+      queue = queue.then(() => getFrameFromTimestamp(timestamp));
+      return queue;
+    },
+    prepareForDeletion,
+    hasTimestampInSecond: (timestamp) => {
+      queue = queue.then(() => hasTimestampInSecond(timestamp));
+      return queue;
+    },
+    addFrame,
+    deleteFramesBeforeTimestamp,
+    src,
+    getOpenFrameCount,
+    getLastUsed,
+    canSatisfyTimestamp,
+    getRangeOfTimestamps
   };
-};
-var getFramesSinceKeyframe = async ({
-  packetSink,
-  videoSampleSink,
-  startPacket,
-  logLevel,
-  src
-}) => {
-  const nextKeyPacket = await packetSink.getNextKeyPacket(startPacket, {
-    verifyKeyPackets: true
-  });
-  const sampleIterator = videoSampleSink.samples(startPacket.timestamp, nextKeyPacket ? nextKeyPacket.timestamp : Infinity);
-  const keyframeBank = makeKeyframeBank({
-    startTimestampInSeconds: startPacket.timestamp,
-    endTimestampInSeconds: nextKeyPacket ? nextKeyPacket.timestamp : Infinity,
-    sampleIterator,
-    logLevel,
-    src
-  });
   return keyframeBank;
 };
 
 // src/video-extraction/keyframe-manager.ts
 var makeKeyframeManager = () => {
-  const sources = {};
-  const addKeyframeBank = ({
-    src,
-    bank,
-    startTimestampInSeconds
-  }) => {
-    sources[src] = sources[src] ?? {};
-    sources[src][startTimestampInSeconds] = bank;
+  let sources = {};
+  const addKeyframeBank = ({ src, bank }) => {
+    sources[src] = sources[src] ?? [];
+    sources[src].push(bank);
   };
-  const logCacheStats = async (logLevel) => {
+  const logCacheStats = (logLevel) => {
     let count = 0;
     let totalSize = 0;
     for (const src in sources) {
-      for (const bank in sources[src]) {
-        const v = await sources[src][bank];
-        const { size, timestamps } = v.getOpenFrameCount();
+      for (const bank of sources[src]) {
+        const { size, timestamps } = bank.getOpenFrameCount();
         count += timestamps.length;
         totalSize += size;
         if (size === 0) {
@@ -2575,13 +2463,12 @@ var makeKeyframeManager = () => {
     }
     Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Video cache stats: ${count} open frames, ${totalSize} bytes`);
   };
-  const getCacheStats = async () => {
+  const getCacheStats = () => {
     let count = 0;
     let totalSize = 0;
     for (const src in sources) {
-      for (const bank in sources[src]) {
-        const v = await sources[src][bank];
-        const { timestamps, size } = v.getOpenFrameCount();
+      for (const bank of sources[src]) {
+        const { timestamps, size } = bank.getOpenFrameCount();
         count += timestamps.length;
         totalSize += size;
         if (size === 0) {
@@ -2591,17 +2478,17 @@ var makeKeyframeManager = () => {
     }
     return { count, totalSize };
   };
-  const getTheKeyframeBankMostInThePast = async () => {
+  const getTheKeyframeBankMostInThePast = () => {
     let mostInThePast = null;
     let mostInThePastBank = null;
     let numberOfBanks = 0;
     for (const src in sources) {
-      for (const b in sources[src]) {
-        const bank = await sources[src][b];
+      for (const bank of sources[src]) {
+        const index = sources[src].indexOf(bank);
         const lastUsed = bank.getLastUsed();
         if (mostInThePast === null || lastUsed < mostInThePast) {
           mostInThePast = lastUsed;
-          mostInThePastBank = { src, bank };
+          mostInThePastBank = { src, bank, index };
         }
         numberOfBanks++;
       }
@@ -2613,47 +2500,64 @@ var makeKeyframeManager = () => {
   };
   const deleteOldestKeyframeBank = async (logLevel) => {
     const {
-      mostInThePastBank: { bank: mostInThePastBank, src: mostInThePastSrc },
+      mostInThePastBank: {
+        bank: mostInThePastBank,
+        src: mostInThePastSrc,
+        index: mostInThePastIndex
+      },
       numberOfBanks
     } = await getTheKeyframeBankMostInThePast();
     if (numberOfBanks < 2) {
       return { finish: true };
     }
     if (mostInThePastBank) {
-      const { framesDeleted } = mostInThePastBank.prepareForDeletion(logLevel);
-      delete sources[mostInThePastSrc][mostInThePastBank.startTimestampInSeconds];
-      Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${framesDeleted} frames for src ${mostInThePastSrc} from ${mostInThePastBank.startTimestampInSeconds}sec to ${mostInThePastBank.endTimestampInSeconds}sec to free up memory.`);
+      const range = mostInThePastBank.getRangeOfTimestamps();
+      const { framesDeleted } = mostInThePastBank.prepareForDeletion(logLevel, "deleted oldest keyframe bank to stay under max cache size");
+      delete sources[mostInThePastSrc][mostInThePastIndex];
+      if (range) {
+        Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${framesDeleted} frames for src ${mostInThePastSrc} from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec to free up memory.`);
+      }
     }
     return { finish: false };
   };
   const ensureToStayUnderMaxCacheSize = async (logLevel, maxCacheSize) => {
     let cacheStats = await getTotalCacheStats();
-    while (cacheStats.totalSize > maxCacheSize) {
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (cacheStats.totalSize > maxCacheSize && attempts < maxAttempts) {
       const { finish } = await deleteOldestKeyframeBank(logLevel);
       if (finish) {
         break;
       }
       Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, "Deleted oldest keyframe bank to stay under max cache size", (cacheStats.totalSize / 1024 / 1024).toFixed(1), "out of", (maxCacheSize / 1024 / 1024).toFixed(1));
       cacheStats = await getTotalCacheStats();
+      attempts++;
+    }
+    if (cacheStats.totalSize > maxCacheSize && attempts >= maxAttempts) {
+      Internals10.Log.warn({ logLevel, tag: "@remotion/media" }, `Exceeded max cache size after ${maxAttempts} attempts. Remaining cache size: ${(cacheStats.totalSize / 1024 / 1024).toFixed(1)} MB, target was ${(maxCacheSize / 1024 / 1024).toFixed(1)} MB.`);
     }
   };
-  const clearKeyframeBanksBeforeTime = async ({
+  const clearKeyframeBanksBeforeTime = ({
     timestampInSeconds,
     src,
     logLevel
   }) => {
-    const threshold = timestampInSeconds - SAFE_BACK_WINDOW_IN_SECONDS;
+    const threshold = timestampInSeconds - SAFE_WINDOW_OF_MONOTONICITY;
     if (!sources[src]) {
       return;
     }
-    const banks = Object.keys(sources[src]);
-    for (const startTimeInSeconds of banks) {
-      const bank = await sources[src][startTimeInSeconds];
-      const { endTimestampInSeconds, startTimestampInSeconds } = bank;
-      if (endTimestampInSeconds < threshold) {
-        bank.prepareForDeletion(logLevel);
-        Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `[Video] Cleared frames for src ${src} from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
-        delete sources[src][startTimeInSeconds];
+    const banks = sources[src];
+    for (const bank of banks) {
+      const range = bank.getRangeOfTimestamps();
+      if (!range) {
+        continue;
+      }
+      const { lastTimestamp } = range;
+      if (lastTimestamp < threshold) {
+        bank.prepareForDeletion(logLevel, "cleared before 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];
       } else {
         bank.deleteFramesBeforeTimestamp({
           timestampInSeconds: threshold,
@@ -2661,56 +2565,45 @@ var makeKeyframeManager = () => {
         });
       }
     }
-    await logCacheStats(logLevel);
+    sources[src] = sources[src].filter((bank) => bank !== undefined);
+    logCacheStats(logLevel);
   };
   const getKeyframeBankOrRefetch = async ({
-    packetSink,
     timestamp,
     videoSampleSink,
     src,
     logLevel
   }) => {
-    const startPacket = await packetSink.getKeyPacket(timestamp, {
-      verifyKeyPackets: true
-    }) ?? await packetSink.getFirstPacket({ verifyKeyPackets: true });
-    const hasAlpha = startPacket?.sideData.alpha;
-    if (hasAlpha && !canBrowserUseWebGl2()) {
-      return "has-alpha";
-    }
-    if (!startPacket) {
-      return null;
-    }
-    const startTimestampInSeconds = startPacket.timestamp;
-    const existingBank = sources[src]?.[startTimestampInSeconds];
+    const existingBanks = sources[src] ?? [];
+    const existingBank = existingBanks?.find((bank) => bank.canSatisfyTimestamp(timestamp));
     if (!existingBank) {
-      const newKeyframeBank = getFramesSinceKeyframe({
-        packetSink,
+      Internals10.Log.trace({ logLevel, tag: "@remotion/media" }, `Creating new keyframe bank for src ${src} at timestamp ${timestamp}`);
+      const newKeyframeBank = await makeKeyframeBank({
         videoSampleSink,
-        startPacket,
         logLevel,
-        src
+        src,
+        requestedTimestamp: timestamp
       });
-      addKeyframeBank({ src, bank: newKeyframeBank, startTimestampInSeconds });
+      addKeyframeBank({ src, bank: newKeyframeBank });
       return newKeyframeBank;
     }
-    if (await (await existingBank).hasTimestampInSecond(timestamp)) {
+    if (existingBank.canSatisfyTimestamp(timestamp)) {
+      Internals10.Log.trace({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists and satisfies timestamp ${timestamp}`);
       return existingBank;
     }
     Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists but frame at time ${timestamp} does not exist anymore.`);
-    await (await existingBank).prepareForDeletion(logLevel);
-    delete sources[src][startTimestampInSeconds];
-    const replacementKeybank = getFramesSinceKeyframe({
-      packetSink,
+    existingBank.prepareForDeletion(logLevel, "already existed but evicted");
+    sources[src] = sources[src].filter((bank) => bank !== existingBank);
+    const replacementKeybank = await makeKeyframeBank({
       videoSampleSink,
-      startPacket,
+      requestedTimestamp: timestamp,
       logLevel,
       src
     });
-    addKeyframeBank({ src, bank: replacementKeybank, startTimestampInSeconds });
+    addKeyframeBank({ src, bank: replacementKeybank });
     return replacementKeybank;
   };
   const requestKeyframeBank = async ({
-    packetSink,
     timestamp,
     videoSampleSink,
     src,
@@ -2718,13 +2611,12 @@ var makeKeyframeManager = () => {
     maxCacheSize
   }) => {
     await ensureToStayUnderMaxCacheSize(logLevel, maxCacheSize);
-    await clearKeyframeBanksBeforeTime({
+    clearKeyframeBanksBeforeTime({
       timestampInSeconds: timestamp,
       src,
       logLevel
     });
     const keyframeBank = await getKeyframeBankOrRefetch({
-      packetSink,
       timestamp,
       videoSampleSink,
       src,
@@ -2732,21 +2624,20 @@ var makeKeyframeManager = () => {
     });
     return keyframeBank;
   };
-  const clearAll = async (logLevel) => {
+  const clearAll = (logLevel) => {
     const srcs = Object.keys(sources);
     for (const src of srcs) {
-      const banks = Object.keys(sources[src]);
-      for (const startTimeInSeconds of banks) {
-        const bank = await sources[src][startTimeInSeconds];
-        bank.prepareForDeletion(logLevel);
-        delete sources[src][startTimeInSeconds];
+      const banks = sources[src];
+      for (const bank of banks) {
+        bank.prepareForDeletion(logLevel, "clearAll");
       }
+      sources[src] = [];
     }
+    sources = {};
   };
   let queue = Promise.resolve(undefined);
   return {
     requestKeyframeBank: ({
-      packetSink,
       timestamp,
       videoSampleSink,
       src,
@@ -2754,7 +2645,6 @@ var makeKeyframeManager = () => {
       maxCacheSize
     }) => {
       queue = queue.then(() => requestKeyframeBank({
-        packetSink,
         timestamp,
         videoSampleSink,
         src,
@@ -2769,7 +2659,7 @@ var makeKeyframeManager = () => {
 };
 
 // src/caches.ts
-var SAFE_BACK_WINDOW_IN_SECONDS = 1;
+var SAFE_WINDOW_OF_MONOTONICITY = 0.2;
 var keyframeManager = makeKeyframeManager();
 var audioManager = makeAudioManager();
 var getTotalCacheStats = async () => {
@@ -3041,6 +2931,154 @@ var combineAudioDataAndClosePrevious = (audioDataArray) => {
 
 // src/get-sink.ts
 import { Internals as Internals12 } from "remotion";
+
+// src/video-extraction/get-frames-since-keyframe.ts
+import {
+  ALL_FORMATS as ALL_FORMATS2,
+  AudioSampleSink,
+  EncodedPacketSink,
+  Input as Input2,
+  MATROSKA,
+  UrlSource as UrlSource2,
+  VideoSampleSink,
+  WEBM
+} from "mediabunny";
+
+// src/browser-can-use-webgl2.ts
+var browserCanUseWebGl2 = null;
+var browserCanUseWebGl2Uncached = () => {
+  const canvas = new OffscreenCanvas(1, 1);
+  const context = canvas.getContext("webgl2");
+  return context !== null;
+};
+var canBrowserUseWebGl2 = () => {
+  if (browserCanUseWebGl2 !== null) {
+    return browserCanUseWebGl2;
+  }
+  browserCanUseWebGl2 = browserCanUseWebGl2Uncached();
+  return browserCanUseWebGl2;
+};
+
+// src/video-extraction/remember-actual-matroska-timestamps.ts
+var rememberActualMatroskaTimestamps = (isMatroska) => {
+  const observations = [];
+  const observeTimestamp = (startTime) => {
+    if (!isMatroska) {
+      return;
+    }
+    observations.push(startTime);
+  };
+  const getRealTimestamp = (observedTimestamp) => {
+    if (!isMatroska) {
+      return observedTimestamp;
+    }
+    return observations.find((observation) => Math.abs(observedTimestamp - observation) < 0.001) ?? null;
+  };
+  return {
+    observeTimestamp,
+    getRealTimestamp
+  };
+};
+
+// src/video-extraction/get-frames-since-keyframe.ts
+var getRetryDelay = () => {
+  return null;
+};
+var getFormatOrNullOrNetworkError = async (input) => {
+  try {
+    return await input.getFormat();
+  } catch (err) {
+    if (isNetworkError(err)) {
+      return "network-error";
+    }
+    return null;
+  }
+};
+var getSinks = async (src) => {
+  const input = new Input2({
+    formats: ALL_FORMATS2,
+    source: new UrlSource2(src, {
+      getRetryDelay
+    })
+  });
+  const format = await getFormatOrNullOrNetworkError(input);
+  const isMatroska = format === MATROSKA || format === WEBM;
+  const getVideoSinks = async () => {
+    if (format === "network-error") {
+      return "network-error";
+    }
+    if (format === null) {
+      return "unknown-container-format";
+    }
+    const videoTrack = await input.getPrimaryVideoTrack();
+    if (!videoTrack) {
+      return "no-video-track";
+    }
+    const canDecode = await videoTrack.canDecode();
+    if (!canDecode) {
+      return "cannot-decode";
+    }
+    const sampleSink = new VideoSampleSink(videoTrack);
+    const packetSink = new EncodedPacketSink(videoTrack);
+    const startPacket = await packetSink.getFirstPacket({
+      verifyKeyPackets: true
+    });
+    const hasAlpha = startPacket?.sideData.alpha;
+    if (hasAlpha && !canBrowserUseWebGl2()) {
+      return "cannot-decode-alpha";
+    }
+    return {
+      sampleSink
+    };
+  };
+  let videoSinksPromise = null;
+  const getVideoSinksPromise = () => {
+    if (videoSinksPromise) {
+      return videoSinksPromise;
+    }
+    videoSinksPromise = getVideoSinks();
+    return videoSinksPromise;
+  };
+  const audioSinksPromise = {};
+  const getAudioSinks = async (index) => {
+    if (format === null) {
+      return "unknown-container-format";
+    }
+    if (format === "network-error") {
+      return "network-error";
+    }
+    const audioTracks = await input.getAudioTracks();
+    const audioTrack = audioTracks[index];
+    if (!audioTrack) {
+      return "no-audio-track";
+    }
+    const canDecode = await audioTrack.canDecode();
+    if (!canDecode) {
+      return "cannot-decode-audio";
+    }
+    return {
+      sampleSink: new AudioSampleSink(audioTrack)
+    };
+  };
+  const getAudioSinksPromise = (index) => {
+    if (audioSinksPromise[index]) {
+      return audioSinksPromise[index];
+    }
+    audioSinksPromise[index] = getAudioSinks(index);
+    return audioSinksPromise[index];
+  };
+  return {
+    getVideo: () => getVideoSinksPromise(),
+    getAudio: (index) => getAudioSinksPromise(index),
+    actualMatroskaTimestamps: rememberActualMatroskaTimestamps(isMatroska),
+    isMatroska,
+    getDuration: () => {
+      return input.computeDuration();
+    }
+  };
+};
+
+// src/get-sink.ts
 var sinkPromises = {};
 var getSink = (src, logLevel) => {
   let promise = sinkPromises[src];
@@ -3215,6 +3253,12 @@ var extractFrameInternal = async ({
   if (video === "network-error") {
     return { type: "network-error" };
   }
+  if (video === "cannot-decode-alpha") {
+    return {
+      type: "cannot-decode-alpha",
+      durationInSeconds: mediaDurationInSeconds
+    };
+  }
   const timeInSeconds = getTimeInSeconds({
     loop,
     mediaDurationInSeconds,
@@ -3229,36 +3273,29 @@ var extractFrameInternal = async ({
   if (timeInSeconds === null) {
     return {
       type: "success",
-      frame: null,
+      sample: null,
       durationInSeconds: await sink.getDuration()
     };
   }
   try {
     const keyframeBank = await keyframeManager.requestKeyframeBank({
-      packetSink: video.packetSink,
       videoSampleSink: video.sampleSink,
       timestamp: timeInSeconds,
       src,
       logLevel,
       maxCacheSize
     });
-    if (keyframeBank === "has-alpha") {
-      return {
-        type: "cannot-decode-alpha",
-        durationInSeconds: await sink.getDuration()
-      };
-    }
     if (!keyframeBank) {
       return {
         type: "success",
-        frame: null,
+        sample: null,
         durationInSeconds: await sink.getDuration()
       };
     }
     const frame = await keyframeBank.getFrameFromTimestamp(timeInSeconds);
     return {
       type: "success",
-      frame,
+      sample: frame,
       durationInSeconds: await sink.getDuration()
     };
   } catch (err) {
@@ -3322,7 +3359,7 @@ var extractFrameAndAudio = async ({
   maxCacheSize
 }) => {
   try {
-    const [frame, audio] = await Promise.all([
+    const [video, audio] = await Promise.all([
       includeVideo ? extractFrame({
         src,
         timeInSeconds,
@@ -3348,59 +3385,42 @@ var extractFrameAndAudio = async ({
         maxCacheSize
       }) : null
     ]);
-    if (frame?.type === "cannot-decode") {
+    if (video?.type === "cannot-decode") {
       return {
         type: "cannot-decode",
-        durationInSeconds: frame.durationInSeconds
+        durationInSeconds: video.durationInSeconds
       };
     }
-    if (frame?.type === "unknown-container-format") {
+    if (video?.type === "unknown-container-format") {
       return { type: "unknown-container-format" };
     }
-    if (frame?.type === "cannot-decode-alpha") {
+    if (video?.type === "cannot-decode-alpha") {
       return {
         type: "cannot-decode-alpha",
-        durationInSeconds: frame.durationInSeconds
+        durationInSeconds: video.durationInSeconds
       };
     }
-    if (frame?.type === "network-error") {
+    if (video?.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
+        durationInSeconds: video?.type === "success" ? video.durationInSeconds : null
       };
     }
     return {
       type: "success",
-      frame: await rotateFrame({
-        frame: frame.frame.toVideoFrame(),
-        rotation: frame.frame.rotation
-      }),
+      frame: video?.sample ? await rotateFrame({
+        frame: video.sample.toVideoFrame(),
+        rotation: video.sample.rotation
+      }) : null,
       audio: audio?.data ?? null,
       durationInSeconds: audio?.durationInSeconds ?? null
     };
@@ -3667,7 +3687,7 @@ var AudioForRendering = ({
   loopVolumeCurveBehavior,
   delayRenderRetries,
   delayRenderTimeoutInMilliseconds,
-  logLevel = window.remotion_logLevel ?? "info",
+  logLevel: overriddenLogLevel,
   loop,
   fallbackHtml5AudioProps,
   audioStreamIndex,
@@ -3679,6 +3699,8 @@ var AudioForRendering = ({
   trimAfter,
   trimBefore
 }) => {
+  const defaultLogLevel = Internals14.useLogLevel();
+  const logLevel = overriddenLogLevel ?? defaultLogLevel;
   const frame = useCurrentFrame3();
   const absoluteFrame = Internals14.useTimelinePosition();
   const videoConfig = Internals14.useUnsafeVideoConfig();
@@ -3701,7 +3723,7 @@ var AudioForRendering = ({
     sequenceContext?.relativeFrom,
     sequenceContext?.durationInFrames
   ]);
-  const maxCacheSize = useMaxMediaCacheSize(logLevel ?? window.remotion_logLevel);
+  const maxCacheSize = useMaxMediaCacheSize(logLevel);
   const audioEnabled = Internals14.useAudioEnabled();
   useLayoutEffect2(() => {
     const timestamp = frame / fps;
@@ -3730,7 +3752,7 @@ var AudioForRendering = ({
       timeInSeconds: timestamp,
       durationInSeconds,
       playbackRate: playbackRate ?? 1,
-      logLevel: logLevel ?? window.remotion_logLevel,
+      logLevel,
       includeAudio: shouldRenderAudio,
       includeVideo: false,
       isClientSideRendering: environment.isClientSideRendering,
@@ -3750,7 +3772,7 @@ var AudioForRendering = ({
           cancelRender2(new Error(`Unknown container format ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
         }
         Internals14.Log.warn({
-          logLevel: logLevel ?? window.remotion_logLevel,
+          logLevel,
           tag: "@remotion/media"
         }, `Unknown container format for ${src} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Html5Audio>`);
         setReplaceWithHtml5Audio(true);
@@ -3765,7 +3787,7 @@ var AudioForRendering = ({
           cancelRender2(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
         }
         Internals14.Log.warn({
-          logLevel: logLevel ?? window.remotion_logLevel,
+          logLevel,
           tag: "@remotion/media"
         }, `Cannot decode ${src}, falling back to <Html5Audio>`);
         setReplaceWithHtml5Audio(true);
@@ -3783,7 +3805,7 @@ var AudioForRendering = ({
           cancelRender2(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
         }
         Internals14.Log.warn({
-          logLevel: logLevel ?? window.remotion_logLevel,
+          logLevel,
           tag: "@remotion/media"
         }, `Network error fetching ${src}, falling back to <Html5Audio>`);
         setReplaceWithHtml5Audio(true);
@@ -4026,8 +4048,6 @@ var VideoForPreviewAssertedShowing = ({
   useEffect3(() => {
     if (!sharedAudioContext)
       return;
-    if (!sharedAudioContext.audioContext)
-      return;
     try {
       const player = new MediaPlayer({
         canvas: canvasRef.current,
@@ -4734,6 +4754,7 @@ var Video = ({
   debugOverlay,
   headless
 }) => {
+  const fallbackLogLevel = Internals18.useLogLevel();
   return /* @__PURE__ */ jsx6(InnerVideo, {
     audioStreamIndex: audioStreamIndex ?? 0,
     className,
@@ -4741,7 +4762,7 @@ var Video = ({
     delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? null,
     disallowFallbackToOffthreadVideo: disallowFallbackToOffthreadVideo ?? false,
     fallbackOffthreadVideoProps: fallbackOffthreadVideoProps ?? {},
-    logLevel: logLevel ?? (typeof window !== "undefined" ? window.remotion_logLevel ?? "info" : "info"),
+    logLevel: logLevel ?? fallbackLogLevel,
     loop: loop ?? false,
     loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? "repeat",
     muted: muted ?? false,