@remotion/media 4.0.364 → 4.0.366

package/dist/esm/index.mjs

@@ -1,116 +1,505 @@
 // src/audio/audio.tsx
-import { Internals as Internals13, useRemotionEnvironment as useRemotionEnvironment2 } from "remotion";
+import { Internals as Internals14, useRemotionEnvironment as useRemotionEnvironment2 } from "remotion";
 
 // src/audio/audio-for-preview.tsx
 import { useContext as useContext2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
 import {
-  Internals as Internals5,
+  Internals as Internals6,
   Audio as RemotionAudio,
   useBufferState,
-  useCurrentFrame as useCurrentFrame2
+  useCurrentFrame as useCurrentFrame2,
+  useVideoConfig as useVideoConfig2
 } from "remotion";
 
+// src/get-time-in-seconds.ts
+import { Internals } from "remotion";
+var 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,
+    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;
+};
+
 // src/media-player.ts
-import {
-  ALL_FORMATS,
-  AudioBufferSink,
-  CanvasSink,
-  Input,
-  UrlSource
-} from "mediabunny";
-import { Internals as Internals2 } from "remotion";
+import { ALL_FORMATS, Input, UrlSource } from "mediabunny";
+import { Internals as Internals3 } from "remotion";
+
+// src/audio-iterator-manager.ts
+import { AudioBufferSink } from "mediabunny";
+
+// src/helpers/round-to-4-digits.ts
+var roundTo4Digits = (timestamp) => {
+  return Math.round(timestamp * 1000) / 1000;
+};
 
 // src/audio/audio-preview-iterator.ts
-var HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
 var makeAudioIterator = (audioSink, startFromSecond) => {
   let destroyed = false;
   const iterator = audioSink.buffers(startFromSecond);
-  let audioIteratorStarted = false;
-  let audioBufferHealth = 0;
-  const queuedAudioNodes = new Set;
+  const queuedAudioNodes = [];
+  const audioChunksForAfterResuming = [];
   const cleanupAudioQueue = () => {
     for (const node of queuedAudioNodes) {
-      node.stop();
+      node.node.stop();
+    }
+    queuedAudioNodes.length = 0;
+  };
+  let lastReturnedBuffer = null;
+  let iteratorEnded = false;
+  const getNextOrNullIfNotAvailable = async (allowWait) => {
+    const next = iterator.next();
+    const result = allowWait ? await next : await Promise.race([
+      next,
+      new Promise((resolve) => {
+        Promise.resolve().then(() => resolve());
+      })
+    ]);
+    if (!result) {
+      return {
+        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;
     }
-    queuedAudioNodes.clear();
+    return {
+      type: "got-buffer-or-end",
+      buffer: result.value ?? null
+    };
+  };
+  const tryToSatisfySeek = async (time, allowWait) => {
+    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) {
+        return {
+          type: "satisfied",
+          buffers: [lastReturnedBuffer]
+        };
+      }
+    }
+    if (iteratorEnded) {
+      return {
+        type: "satisfied",
+        buffers: lastReturnedBuffer ? [lastReturnedBuffer] : []
+      };
+    }
+    const toBeReturned = [];
+    while (true) {
+      const buffer = await getNextOrNullIfNotAvailable(allowWait);
+      if (buffer.type === "need-to-wait-for-it") {
+        return {
+          type: "not-satisfied",
+          reason: "iterator did not have buffer ready"
+        };
+      }
+      if (buffer.type === "got-buffer-or-end") {
+        if (buffer.buffer === null) {
+          iteratorEnded = true;
+          return {
+            type: "satisfied",
+            buffers: lastReturnedBuffer ? [lastReturnedBuffer] : []
+          };
+        }
+        const bufferTimestamp = roundTo4Digits(buffer.buffer.timestamp);
+        const bufferEndTimestamp = roundTo4Digits(buffer.buffer.timestamp + buffer.buffer.duration);
+        const timestamp = roundTo4Digits(time);
+        if (bufferTimestamp <= timestamp && bufferEndTimestamp > timestamp) {
+          return {
+            type: "satisfied",
+            buffers: [...toBeReturned, buffer.buffer]
+          };
+        }
+        toBeReturned.push(buffer.buffer);
+        continue;
+      }
+      throw new Error("Unreachable");
+    }
+  };
+  const removeAndReturnAllQueuedAudioNodes = () => {
+    const nodes = queuedAudioNodes.slice();
+    for (const node of nodes) {
+      node.node.stop();
+    }
+    queuedAudioNodes.length = 0;
+    return nodes;
+  };
+  const addChunkForAfterResuming = (buffer, timestamp) => {
+    audioChunksForAfterResuming.push({ buffer, timestamp });
+  };
+  const moveQueuedChunksToPauseQueue = () => {
+    const toQueue = removeAndReturnAllQueuedAudioNodes();
+    for (const chunk of toQueue) {
+      addChunkForAfterResuming(chunk.buffer, chunk.timestamp);
+    }
+  };
+  const getNumberOfChunksAfterResuming = () => {
+    return audioChunksForAfterResuming.length;
   };
   return {
-    cleanupAudioQueue,
     destroy: () => {
       cleanupAudioQueue();
       destroyed = true;
       iterator.return().catch(() => {
         return;
       });
+      audioChunksForAfterResuming.length = 0;
     },
-    isReadyToPlay: () => {
-      return audioIteratorStarted && audioBufferHealth > 0;
-    },
-    setAudioIteratorStarted: (started) => {
-      audioIteratorStarted = started;
-    },
-    getNext: () => {
-      return iterator.next();
-    },
-    setAudioBufferHealth: (health) => {
-      audioBufferHealth = health;
+    getNext: async () => {
+      const next = await iterator.next();
+      if (next.value) {
+        lastReturnedBuffer = next.value;
+      } else {
+        iteratorEnded = true;
+      }
+      return next;
     },
     isDestroyed: () => {
       return destroyed;
     },
-    addQueuedAudioNode: (node) => {
-      queuedAudioNodes.add(node);
+    addQueuedAudioNode: (node, timestamp, buffer) => {
+      queuedAudioNodes.push({ node, timestamp, buffer });
     },
     removeQueuedAudioNode: (node) => {
-      queuedAudioNodes.delete(node);
+      const index = queuedAudioNodes.findIndex((n) => n.node === node);
+      if (index !== -1) {
+        queuedAudioNodes.splice(index, 1);
+      }
+    },
+    getAndClearAudioChunksForAfterResuming: () => {
+      const chunks = audioChunksForAfterResuming.slice();
+      audioChunksForAfterResuming.length = 0;
+      return chunks;
+    },
+    getQueuedPeriod: (pendingBuffers) => {
+      let until = -Infinity;
+      let from = Infinity;
+      for (const buffer of pendingBuffers) {
+        until = Math.max(until, buffer.timestamp + buffer.duration);
+        from = Math.min(from, buffer.timestamp);
+      }
+      for (const node of queuedAudioNodes) {
+        until = Math.max(until, node.timestamp + node.buffer.duration);
+        from = Math.min(from, node.timestamp);
+      }
+      for (const chunk of audioChunksForAfterResuming) {
+        until = Math.max(until, chunk.timestamp + chunk.buffer.duration);
+        from = Math.min(from, chunk.timestamp);
+      }
+      if (!Number.isFinite(from) || !Number.isFinite(until)) {
+        return null;
+      }
+      return {
+        from,
+        until
+      };
+    },
+    tryToSatisfySeek,
+    addChunkForAfterResuming,
+    moveQueuedChunksToPauseQueue,
+    getNumberOfChunksAfterResuming
+  };
+};
+var isAlreadyQueued = (time, queuedPeriod) => {
+  if (!queuedPeriod) {
+    return false;
+  }
+  return time >= queuedPeriod.from && time < queuedPeriod.until;
+};
+
+// src/audio-iterator-manager.ts
+var audioIteratorManager = ({
+  audioTrack,
+  delayPlaybackHandleIfNotPremounting,
+  sharedAudioContext
+}) => {
+  let muted = false;
+  let currentVolume = 1;
+  const gainNode = sharedAudioContext.createGain();
+  gainNode.connect(sharedAudioContext.destination);
+  const audioSink = new AudioBufferSink(audioTrack);
+  let audioBufferIterator = null;
+  let audioIteratorsCreated = 0;
+  const scheduleAudioChunk = ({
+    buffer,
+    mediaTimestamp,
+    playbackRate,
+    scheduleAudioNode
+  }) => {
+    if (!audioBufferIterator) {
+      throw new Error("Audio buffer iterator not found");
+    }
+    const node = sharedAudioContext.createBufferSource();
+    node.buffer = buffer;
+    node.playbackRate.value = playbackRate;
+    node.connect(gainNode);
+    scheduleAudioNode(node, mediaTimestamp);
+    const iterator = audioBufferIterator;
+    iterator.addQueuedAudioNode(node, mediaTimestamp, buffer);
+    node.onended = () => {
+      setTimeout(() => {
+        iterator.removeQueuedAudioNode(node);
+      }, 30);
+    };
+  };
+  const onAudioChunk = ({
+    getIsPlaying,
+    buffer,
+    playbackRate,
+    scheduleAudioNode
+  }) => {
+    if (getIsPlaying()) {
+      scheduleAudioChunk({
+        buffer: buffer.buffer,
+        mediaTimestamp: buffer.timestamp,
+        playbackRate,
+        scheduleAudioNode
+      });
+    } else {
+      if (!audioBufferIterator) {
+        throw new Error("Audio buffer iterator not found");
+      }
+      audioBufferIterator.addChunkForAfterResuming(buffer.buffer, buffer.timestamp);
     }
   };
+  const startAudioIterator = async ({
+    nonce,
+    playbackRate,
+    startFromSecond,
+    getIsPlaying,
+    scheduleAudioNode
+  }) => {
+    audioBufferIterator?.destroy();
+    const delayHandle = delayPlaybackHandleIfNotPremounting();
+    const iterator = makeAudioIterator(audioSink, startFromSecond);
+    audioIteratorsCreated++;
+    audioBufferIterator = iterator;
+    for (let i = 0;i < 3; i++) {
+      const result = await iterator.getNext();
+      if (iterator.isDestroyed()) {
+        delayHandle.unblock();
+        return;
+      }
+      if (nonce.isStale()) {
+        delayHandle.unblock();
+        return;
+      }
+      if (!result.value) {
+        delayHandle.unblock();
+        return;
+      }
+      onAudioChunk({
+        getIsPlaying,
+        buffer: result.value,
+        playbackRate,
+        scheduleAudioNode
+      });
+    }
+    delayHandle.unblock();
+  };
+  const pausePlayback = () => {
+    if (!audioBufferIterator) {
+      return;
+    }
+    audioBufferIterator.moveQueuedChunksToPauseQueue();
+  };
+  const seek = async ({
+    newTime,
+    nonce,
+    fps,
+    playbackRate,
+    getIsPlaying,
+    scheduleAudioNode
+  }) => {
+    if (!audioBufferIterator) {
+      await startAudioIterator({
+        nonce,
+        playbackRate,
+        startFromSecond: newTime,
+        getIsPlaying,
+        scheduleAudioNode
+      });
+      return;
+    }
+    const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, audioBufferIterator.getQueuedPeriod([]));
+    const toBeScheduled = [];
+    if (!currentTimeIsAlreadyQueued) {
+      const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(newTime, false);
+      if (nonce.isStale()) {
+        return;
+      }
+      if (audioSatisfyResult.type === "not-satisfied") {
+        await startAudioIterator({
+          nonce,
+          playbackRate,
+          startFromSecond: newTime,
+          getIsPlaying,
+          scheduleAudioNode
+        });
+        return;
+      }
+      toBeScheduled.push(...audioSatisfyResult.buffers);
+    }
+    const nextTime = newTime + 1 / fps * playbackRate + 1 / fps * playbackRate;
+    const nextIsAlreadyQueued = isAlreadyQueued(nextTime, audioBufferIterator.getQueuedPeriod(toBeScheduled));
+    if (!nextIsAlreadyQueued) {
+      const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(nextTime, true);
+      if (nonce.isStale()) {
+        return;
+      }
+      if (audioSatisfyResult.type === "not-satisfied") {
+        await startAudioIterator({
+          nonce,
+          playbackRate,
+          startFromSecond: newTime,
+          getIsPlaying,
+          scheduleAudioNode
+        });
+        return;
+      }
+      toBeScheduled.push(...audioSatisfyResult.buffers);
+    }
+    for (const buffer of toBeScheduled) {
+      onAudioChunk({
+        getIsPlaying,
+        buffer,
+        playbackRate,
+        scheduleAudioNode
+      });
+    }
+  };
+  const resumeScheduledAudioChunks = ({
+    playbackRate,
+    scheduleAudioNode
+  }) => {
+    if (!audioBufferIterator) {
+      return;
+    }
+    for (const chunk of audioBufferIterator.getAndClearAudioChunksForAfterResuming()) {
+      scheduleAudioChunk({
+        buffer: chunk.buffer,
+        mediaTimestamp: chunk.timestamp,
+        playbackRate,
+        scheduleAudioNode
+      });
+    }
+  };
+  return {
+    startAudioIterator,
+    resumeScheduledAudioChunks,
+    pausePlayback,
+    getAudioBufferIterator: () => audioBufferIterator,
+    destroy: () => {
+      audioBufferIterator?.destroy();
+      audioBufferIterator = null;
+    },
+    seek,
+    getAudioIteratorsCreated: () => audioIteratorsCreated,
+    setMuted: (newMuted) => {
+      muted = newMuted;
+      gainNode.gain.value = muted ? 0 : currentVolume;
+    },
+    setVolume: (volume) => {
+      currentVolume = Math.max(0, volume);
+      gainNode.gain.value = muted ? 0 : currentVolume;
+    },
+    scheduleAudioChunk
+  };
+};
+
+// src/calculate-playbacktime.ts
+var calculatePlaybackTime = ({
+  audioSyncAnchor,
+  currentTime,
+  playbackRate
+}) => {
+  const timeSinceAnchor = currentTime - audioSyncAnchor;
+  return timeSinceAnchor * playbackRate;
 };
 
 // src/debug-overlay/preview-overlay.ts
-var drawPreviewOverlay = (context, stats, audioContextState, audioSyncAnchor) => {
+var drawPreviewOverlay = ({
+  context,
+  audioTime,
+  audioContextState,
+  audioSyncAnchor,
+  playing,
+  audioIteratorManager: audioIteratorManager2,
+  videoIteratorManager
+}) => {
+  const lines = [
+    "Debug overlay",
+    `Video iterators created: ${videoIteratorManager?.getVideoIteratorsCreated()}`,
+    `Audio iterators created: ${audioIteratorManager2?.getAudioIteratorsCreated()}`,
+    `Frames rendered: ${videoIteratorManager?.getFramesRendered()}`,
+    `Audio context state: ${audioContextState}`,
+    `Audio time: ${(audioTime - audioSyncAnchor).toFixed(3)}s`
+  ];
+  if (audioIteratorManager2) {
+    const queuedPeriod = audioIteratorManager2.getAudioBufferIterator()?.getQueuedPeriod([]);
+    const numberOfChunksAfterResuming = audioIteratorManager2?.getAudioBufferIterator()?.getNumberOfChunksAfterResuming();
+    if (queuedPeriod) {
+      lines.push(`Audio queued until: ${(queuedPeriod.until - (audioTime - audioSyncAnchor)).toFixed(3)}s`);
+    } else if (numberOfChunksAfterResuming) {
+      lines.push(`Audio chunks for after resuming: ${numberOfChunksAfterResuming}`);
+    }
+    lines.push(`Playing: ${playing}`);
+  }
+  const lineHeight = 30;
+  const boxPaddingX = 10;
+  const boxPaddingY = 10;
+  const boxLeft = 20;
+  const boxTop = 20;
+  const boxWidth = 600;
+  const boxHeight = lines.length * lineHeight + 2 * boxPaddingY;
   context.fillStyle = "rgba(0, 0, 0, 1)";
-  context.fillRect(20, 20, 600, 180);
+  context.fillRect(boxLeft, boxTop, boxWidth, boxHeight);
   context.fillStyle = "white";
   context.font = "24px sans-serif";
   context.textBaseline = "top";
-  context.fillText(`Debug overlay`, 30, 30);
-  context.fillText(`Video iterators created: ${stats.videoIteratorsCreated}`, 30, 60);
-  context.fillText(`Frames rendered: ${stats.framesRendered}`, 30, 90);
-  context.fillText(`Audio context state: ${audioContextState}`, 30, 120);
-  context.fillText(`Audio time: ${audioSyncAnchor.toFixed(3)}s`, 30, 150);
-};
-
-// src/get-time-in-seconds.ts
-import { Internals } from "remotion";
-var 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,
-    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;
-    }
+  for (let i = 0;i < lines.length; i++) {
+    context.fillText(lines[i], boxLeft + boxPaddingX, boxTop + boxPaddingY + i * lineHeight);
   }
-  return timeInSeconds + (trimBefore ?? 0) / fps;
 };
 
 // src/is-network-error.ts
@@ -121,37 +510,25 @@ function isNetworkError(error) {
   return false;
 }
 
-// src/video/timeout-utils.ts
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-class TimeoutError extends Error {
-  constructor(message = "Operation timed out") {
-    super(message);
-    this.name = "TimeoutError";
-  }
-}
-function withTimeout(promise, timeoutMs, errorMessage = "Operation timed out") {
-  let timeoutId = null;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = window.setTimeout(() => {
-      reject(new TimeoutError(errorMessage));
-    }, timeoutMs);
-  });
-  return Promise.race([
-    promise.finally(() => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    }),
-    timeoutPromise
-  ]);
-}
-
-// src/helpers/round-to-4-digits.ts
-var roundTo4Digits = (timestamp) => {
-  return Math.round(timestamp * 1000) / 1000;
+// src/nonce-manager.ts
+var makeNonceManager = () => {
+  let nonce = 0;
+  const createAsyncOperation = () => {
+    nonce++;
+    const currentNonce = nonce;
+    return {
+      isStale: () => nonce !== currentNonce
+    };
+  };
+  return {
+    createAsyncOperation
+  };
 };
 
+// src/video-iterator-manager.ts
+import { CanvasSink } from "mediabunny";
+import { Internals as Internals2 } from "remotion";
+
 // src/video/video-preview-iterator.ts
 var createVideoIterator = (timeToSeek, videoSink) => {
   let destroyed = false;
@@ -275,43 +652,115 @@ var createVideoIterator = (timeToSeek, videoSink) => {
   };
 };
 
-// src/media-player.ts
-var AUDIO_BUFFER_TOLERANCE_THRESHOLD = 0.1;
+// src/video-iterator-manager.ts
+var videoIteratorManager = ({
+  delayPlaybackHandleIfNotPremounting,
+  canvas,
+  context,
+  drawDebugOverlay,
+  logLevel,
+  getOnVideoFrameCallback,
+  videoTrack
+}) => {
+  let videoIteratorsCreated = 0;
+  let videoFrameIterator = null;
+  let framesRendered = 0;
+  canvas.width = videoTrack.displayWidth;
+  canvas.height = videoTrack.displayHeight;
+  const canvasSink = new CanvasSink(videoTrack, {
+    poolSize: 2,
+    fit: "contain",
+    alpha: true
+  });
+  const drawFrame = (frame) => {
+    context.clearRect(0, 0, canvas.width, canvas.height);
+    context.drawImage(frame.canvas, 0, 0);
+    framesRendered++;
+    drawDebugOverlay();
+    const callback = getOnVideoFrameCallback();
+    if (callback) {
+      callback(canvas);
+    }
+    Internals2.Log.trace({ logLevel, tag: "@remotion/media" }, `[MediaPlayer] Drew frame ${frame.timestamp.toFixed(3)}s`);
+  };
+  const startVideoIterator = async (timeToSeek, nonce) => {
+    videoFrameIterator?.destroy();
+    const iterator = createVideoIterator(timeToSeek, canvasSink);
+    videoIteratorsCreated++;
+    videoFrameIterator = iterator;
+    const delayHandle = delayPlaybackHandleIfNotPremounting();
+    const frameResult = await iterator.getNext();
+    delayHandle.unblock();
+    if (iterator.isDestroyed()) {
+      return;
+    }
+    if (nonce.isStale()) {
+      return;
+    }
+    if (videoFrameIterator.isDestroyed()) {
+      return;
+    }
+    if (!frameResult.value) {
+      return;
+    }
+    drawFrame(frameResult.value);
+  };
+  const seek = async ({ newTime, nonce }) => {
+    if (!videoFrameIterator) {
+      return;
+    }
+    const videoSatisfyResult = await videoFrameIterator.tryToSatisfySeek(newTime);
+    if (videoSatisfyResult.type === "satisfied") {
+      drawFrame(videoSatisfyResult.frame);
+      return;
+    }
+    if (nonce.isStale()) {
+      return;
+    }
+    startVideoIterator(newTime, nonce).catch(() => {});
+  };
+  return {
+    startVideoIterator,
+    getVideoIteratorsCreated: () => videoIteratorsCreated,
+    seek,
+    destroy: () => {
+      videoFrameIterator?.destroy();
+      context.clearRect(0, 0, canvas.width, canvas.height);
+      videoFrameIterator = null;
+    },
+    getVideoFrameIterator: () => videoFrameIterator,
+    drawFrame,
+    getFramesRendered: () => framesRendered
+  };
+};
 
+// src/media-player.ts
 class MediaPlayer {
   canvas;
   context;
   src;
   logLevel;
   playbackRate;
+  globalPlaybackRate;
   audioStreamIndex;
-  canvasSink = null;
-  videoFrameIterator = null;
-  debugStats = {
-    videoIteratorsCreated: 0,
-    framesRendered: 0
-  };
-  audioSink = null;
-  audioBufferIterator = null;
-  gainNode = null;
-  currentVolume = 1;
   sharedAudioContext;
+  audioIteratorManager = null;
+  videoIteratorManager = null;
   audioSyncAnchor = 0;
   playing = false;
-  muted = false;
   loop = false;
   fps;
   trimBefore;
   trimAfter;
-  initialized = false;
   totalDuration;
-  isBuffering = false;
-  onBufferingChangeCallback;
-  mediaEnded = false;
   debugOverlay = false;
-  onVideoFrameCallback;
+  nonceManager;
+  onVideoFrameCallback = null;
   initializationPromise = null;
   bufferState;
+  isPremounting;
+  isPostmounting;
+  seekPromiseChain = Promise.resolve();
   constructor({
     canvas,
     src,
@@ -321,16 +770,20 @@ class MediaPlayer {
     trimBefore,
     trimAfter,
     playbackRate,
+    globalPlaybackRate,
     audioStreamIndex,
     fps,
     debugOverlay,
-    bufferState
+    bufferState,
+    isPremounting,
+    isPostmounting
   }) {
     this.canvas = canvas ?? null;
     this.src = src;
     this.logLevel = logLevel ?? window.remotion_logLevel;
     this.sharedAudioContext = sharedAudioContext;
     this.playbackRate = playbackRate;
+    this.globalPlaybackRate = globalPlaybackRate;
     this.loop = loop;
     this.trimBefore = trimBefore;
     this.trimAfter = trimAfter;
@@ -338,6 +791,13 @@ class MediaPlayer {
     this.fps = fps;
     this.debugOverlay = debugOverlay;
     this.bufferState = bufferState;
+    this.isPremounting = isPremounting;
+    this.isPostmounting = isPostmounting;
+    this.nonceManager = makeNonceManager();
+    this.input = new Input({
+      source: new UrlSource(this.src),
+      formats: ALL_FORMATS
+    });
     if (canvas) {
       const context = canvas.getContext("2d", {
         alpha: true,
@@ -351,18 +811,9 @@ class MediaPlayer {
       this.context = null;
     }
   }
-  input = null;
-  isReady() {
-    return this.initialized && Boolean(this.sharedAudioContext) && !this.input?.disposed;
-  }
-  hasAudio() {
-    return Boolean(this.audioSink && this.sharedAudioContext && this.gainNode);
-  }
-  isCurrentlyBuffering() {
-    return this.isBuffering && Boolean(this.bufferingStartedAtMs);
-  }
+  input;
   isDisposalError() {
-    return this.input?.disposed === true;
+    return this.input.disposed === true;
   }
   initialize(startTimeUnresolved) {
     const promise = this._initialize(startTimeUnresolved);
@@ -371,17 +822,11 @@ class MediaPlayer {
   }
   async _initialize(startTimeUnresolved) {
     try {
-      const urlSource = new UrlSource(this.src);
-      const input = new Input({
-        source: urlSource,
-        formats: ALL_FORMATS
-      });
-      this.input = input;
-      if (input.disposed) {
+      if (this.input.disposed) {
         return { type: "disposed" };
       }
       try {
-        await input.getFormat();
+        await this.input.getFormat();
       } catch (error) {
         if (this.isDisposalError()) {
           return { type: "disposed" };
@@ -390,14 +835,17 @@ class MediaPlayer {
         if (isNetworkError(err)) {
           throw error;
         }
-        Internals2.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Failed to recognize format for ${this.src}`, error);
+        Internals3.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Failed to recognize format for ${this.src}`, error);
         return { type: "unknown-container-format" };
       }
       const [durationInSeconds, videoTrack, audioTracks] = await Promise.all([
-        input.computeDuration(),
-        input.getPrimaryVideoTrack(),
-        input.getAudioTracks()
+        this.input.computeDuration(),
+        this.input.getPrimaryVideoTrack(),
+        this.input.getAudioTracks()
       ]);
+      if (this.input.disposed) {
+        return { type: "disposed" };
+      }
       this.totalDuration = durationInSeconds;
       const audioTrack = audioTracks[this.audioStreamIndex] ?? null;
       if (!videoTrack && !audioTrack) {
@@ -408,18 +856,18 @@ class MediaPlayer {
         if (!canDecode) {
           return { type: "cannot-decode" };
         }
-        this.canvasSink = new CanvasSink(videoTrack, {
-          poolSize: 2,
-          fit: "contain",
-          alpha: true
+        if (this.input.disposed) {
+          return { type: "disposed" };
+        }
+        this.videoIteratorManager = videoIteratorManager({
+          videoTrack,
+          delayPlaybackHandleIfNotPremounting: this.delayPlaybackHandleIfNotPremounting,
+          context: this.context,
+          canvas: this.canvas,
+          getOnVideoFrameCallback: () => this.onVideoFrameCallback,
+          logLevel: this.logLevel,
+          drawDebugOverlay: this.drawDebugOverlay
         });
-        this.canvas.width = videoTrack.displayWidth;
-        this.canvas.height = videoTrack.displayHeight;
-      }
-      if (audioTrack && this.sharedAudioContext) {
-        this.audioSink = new AudioBufferSink(audioTrack);
-        this.gainNode = this.sharedAudioContext.createGain();
-        this.gainNode.connect(this.sharedAudioContext.destination);
       }
       const startTime = getTimeInSeconds({
         unloopedTimeInSeconds: startTimeUnresolved,
@@ -433,53 +881,46 @@ class MediaPlayer {
         src: this.src
       });
       if (startTime === null) {
-        this.clearCanvas();
-        return { type: "success", durationInSeconds: this.totalDuration };
+        throw new Error(`should have asserted that the time is not null`);
       }
-      if (this.sharedAudioContext) {
-        this.audioSyncAnchor = this.sharedAudioContext.currentTime - startTime;
+      this.setPlaybackTime(startTime, this.playbackRate * this.globalPlaybackRate);
+      if (audioTrack) {
+        this.audioIteratorManager = audioIteratorManager({
+          audioTrack,
+          delayPlaybackHandleIfNotPremounting: this.delayPlaybackHandleIfNotPremounting,
+          sharedAudioContext: this.sharedAudioContext
+        });
       }
-      this.initialized = true;
+      const nonce = this.nonceManager.createAsyncOperation();
       try {
-        this.startAudioIterator(startTime);
-        await this.startVideoIterator(startTime, this.currentSeekNonce);
+        if (this.audioIteratorManager) {
+          this.audioIteratorManager.startAudioIterator({
+            nonce,
+            playbackRate: this.playbackRate * this.globalPlaybackRate,
+            startFromSecond: startTime,
+            getIsPlaying: () => this.playing,
+            scheduleAudioNode: this.scheduleAudioNode
+          });
+        }
+        await this.videoIteratorManager?.startVideoIterator(startTime, nonce);
       } catch (error) {
         if (this.isDisposalError()) {
           return { type: "disposed" };
         }
-        Internals2.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to start audio and video iterators", error);
+        Internals3.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to start audio and video iterators", error);
       }
       return { type: "success", durationInSeconds };
     } catch (error) {
       const err = error;
       if (isNetworkError(err)) {
-        Internals2.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Network/CORS error for ${this.src}`, err);
+        Internals3.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Network/CORS error for ${this.src}`, err);
         return { type: "network-error" };
       }
-      Internals2.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to initialize", error);
+      Internals3.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to initialize", error);
       throw error;
     }
   }
-  clearCanvas() {
-    if (this.context && this.canvas) {
-      this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
-    }
-  }
-  currentSeekNonce = 0;
-  seekPromiseChain = Promise.resolve();
   async seekTo(time) {
-    this.currentSeekNonce++;
-    const nonce = this.currentSeekNonce;
-    await this.seekPromiseChain;
-    this.seekPromiseChain = this.seekToDoNotCallDirectly(time, nonce);
-    await this.seekPromiseChain;
-  }
-  async seekToDoNotCallDirectly(time, nonce) {
-    if (nonce !== this.currentSeekNonce) {
-      return;
-    }
-    if (!this.isReady())
-      return;
     const newTime = getTimeInSeconds({
       unloopedTimeInSeconds: time,
       playbackRate: this.playbackRate,
@@ -492,278 +933,189 @@ class MediaPlayer {
       src: this.src
     });
     if (newTime === null) {
-      this.videoFrameIterator?.destroy();
-      this.videoFrameIterator = null;
-      this.clearCanvas();
-      this.audioBufferIterator?.destroy();
-      this.audioBufferIterator = null;
+      throw new Error(`should have asserted that the time is not null`);
+    }
+    const nonce = this.nonceManager.createAsyncOperation();
+    await this.seekPromiseChain;
+    this.seekPromiseChain = this.seekToDoNotCallDirectly(newTime, nonce);
+    await this.seekPromiseChain;
+  }
+  async seekToDoNotCallDirectly(newTime, nonce) {
+    if (nonce.isStale()) {
       return;
     }
     const currentPlaybackTime = this.getPlaybackTime();
     if (currentPlaybackTime === newTime) {
       return;
     }
-    const satisfyResult = await this.videoFrameIterator?.tryToSatisfySeek(newTime);
-    if (satisfyResult?.type === "satisfied") {
-      this.drawFrame(satisfyResult.frame);
-      return;
-    }
-    if (this.currentSeekNonce !== nonce) {
-      return;
+    const newAudioSyncAnchor = this.sharedAudioContext.currentTime - newTime / (this.playbackRate * this.globalPlaybackRate);
+    const diff = Math.abs(newAudioSyncAnchor - this.audioSyncAnchor);
+    if (diff > 0.04) {
+      this.setPlaybackTime(newTime, this.playbackRate * this.globalPlaybackRate);
     }
-    this.mediaEnded = false;
-    this.audioSyncAnchor = this.sharedAudioContext.currentTime - newTime;
-    this.startAudioIterator(newTime);
-    this.startVideoIterator(newTime, nonce);
+    await this.videoIteratorManager?.seek({
+      newTime,
+      nonce
+    });
+    await this.audioIteratorManager?.seek({
+      newTime,
+      nonce,
+      fps: this.fps,
+      playbackRate: this.playbackRate * this.globalPlaybackRate,
+      getIsPlaying: () => this.playing,
+      scheduleAudioNode: this.scheduleAudioNode
+    });
   }
-  async play() {
-    if (!this.isReady())
-      return;
-    if (!this.playing) {
-      if (this.sharedAudioContext.state === "suspended") {
-        await this.sharedAudioContext.resume();
-      }
-      this.playing = true;
+  async play(time) {
+    const newTime = getTimeInSeconds({
+      unloopedTimeInSeconds: time,
+      playbackRate: this.playbackRate,
+      loop: this.loop,
+      trimBefore: this.trimBefore,
+      trimAfter: this.trimAfter,
+      mediaDurationInSeconds: this.totalDuration ?? null,
+      fps: this.fps,
+      ifNoMediaDuration: "infinity",
+      src: this.src
+    });
+    if (newTime === null) {
+      throw new Error(`should have asserted that the time is not null`);
+    }
+    this.setPlaybackTime(newTime, this.playbackRate * this.globalPlaybackRate);
+    this.playing = true;
+    if (this.audioIteratorManager) {
+      this.audioIteratorManager.resumeScheduledAudioChunks({
+        playbackRate: this.playbackRate * this.globalPlaybackRate,
+        scheduleAudioNode: this.scheduleAudioNode
+      });
+    }
+    if (this.sharedAudioContext.state === "suspended") {
+      await this.sharedAudioContext.resume();
     }
+    this.drawDebugOverlay();
   }
+  delayPlaybackHandleIfNotPremounting = () => {
+    if (this.isPremounting || this.isPostmounting) {
+      return {
+        unblock: () => {}
+      };
+    }
+    return this.bufferState.delayPlayback();
+  };
   pause() {
     this.playing = false;
-    this.audioBufferIterator?.cleanupAudioQueue();
+    this.audioIteratorManager?.pausePlayback();
+    this.drawDebugOverlay();
   }
   setMuted(muted) {
-    this.muted = muted;
-    if (this.gainNode) {
-      this.gainNode.gain.value = muted ? 0 : this.currentVolume;
-    }
+    this.audioIteratorManager?.setMuted(muted);
   }
   setVolume(volume) {
-    if (!this.gainNode) {
+    if (!this.audioIteratorManager) {
       return;
     }
-    const appliedVolume = Math.max(0, volume);
-    this.currentVolume = appliedVolume;
-    if (!this.muted) {
-      this.gainNode.gain.value = appliedVolume;
-    }
+    this.audioIteratorManager.setVolume(volume);
+  }
+  setTrimBefore(trimBefore) {
+    this.trimBefore = trimBefore;
+  }
+  setTrimAfter(trimAfter) {
+    this.trimAfter = trimAfter;
   }
   setDebugOverlay(debugOverlay) {
     this.debugOverlay = debugOverlay;
   }
+  updateAfterPlaybackRateChange() {
+    if (!this.audioIteratorManager) {
+      return;
+    }
+    this.setPlaybackTime(this.getPlaybackTime(), this.playbackRate * this.globalPlaybackRate);
+    const iterator = this.audioIteratorManager.getAudioBufferIterator();
+    if (!iterator) {
+      return;
+    }
+    iterator.moveQueuedChunksToPauseQueue();
+    if (this.playing) {
+      this.audioIteratorManager.resumeScheduledAudioChunks({
+        playbackRate: this.playbackRate * this.globalPlaybackRate,
+        scheduleAudioNode: this.scheduleAudioNode
+      });
+    }
+  }
   setPlaybackRate(rate) {
     this.playbackRate = rate;
+    this.updateAfterPlaybackRateChange();
+  }
+  setGlobalPlaybackRate(rate) {
+    this.globalPlaybackRate = rate;
+    this.updateAfterPlaybackRateChange();
   }
   setFps(fps) {
     this.fps = fps;
   }
+  setIsPremounting(isPremounting) {
+    this.isPremounting = isPremounting;
+  }
+  setIsPostmounting(isPostmounting) {
+    this.isPostmounting = isPostmounting;
+  }
   setLoop(loop) {
     this.loop = loop;
   }
   async dispose() {
-    this.initialized = false;
     if (this.initializationPromise) {
       try {
         await this.initializationPromise;
       } catch {}
     }
-    this.input?.dispose();
-    this.videoFrameIterator?.destroy();
-    this.videoFrameIterator = null;
-    this.audioBufferIterator?.destroy();
-    this.audioBufferIterator = null;
+    this.nonceManager.createAsyncOperation();
+    this.videoIteratorManager?.destroy();
+    this.audioIteratorManager?.destroy();
+    this.input.dispose();
   }
-  getPlaybackTime() {
-    return this.sharedAudioContext.currentTime - this.audioSyncAnchor;
-  }
-  scheduleAudioChunk(buffer, mediaTimestamp) {
-    const targetTime = mediaTimestamp + this.audioSyncAnchor;
-    const delay = targetTime - this.sharedAudioContext.currentTime;
-    const node = this.sharedAudioContext.createBufferSource();
-    node.buffer = buffer;
-    node.playbackRate.value = this.playbackRate;
-    node.connect(this.gainNode);
+  scheduleAudioNode = (node, mediaTimestamp) => {
+    const currentTime = this.getPlaybackTime();
+    const delayWithoutPlaybackRate = mediaTimestamp - currentTime;
+    const delay = delayWithoutPlaybackRate / (this.playbackRate * this.globalPlaybackRate);
     if (delay >= 0) {
-      node.start(targetTime);
+      node.start(this.sharedAudioContext.currentTime + delay);
     } else {
       node.start(this.sharedAudioContext.currentTime, -delay);
     }
-    this.audioBufferIterator?.addQueuedAudioNode(node);
-    node.onended = () => this.audioBufferIterator?.removeQueuedAudioNode(node);
+  };
+  getPlaybackTime() {
+    return calculatePlaybackTime({
+      audioSyncAnchor: this.audioSyncAnchor,
+      currentTime: this.sharedAudioContext.currentTime,
+      playbackRate: this.playbackRate * this.globalPlaybackRate
+    });
   }
-  onBufferingChange(callback) {
-    this.onBufferingChangeCallback = callback;
-    return () => {
-      if (this.onBufferingChangeCallback === callback) {
-        this.onBufferingChangeCallback = undefined;
-      }
-    };
+  setPlaybackTime(time, playbackRate) {
+    this.audioSyncAnchor = this.sharedAudioContext.currentTime - time / playbackRate;
   }
-  onVideoFrame(callback) {
+  setVideoFrameCallback(callback) {
     this.onVideoFrameCallback = callback;
-    if (this.initialized && callback && this.canvas) {
-      callback(this.canvas);
-    }
-    return () => {
-      if (this.onVideoFrameCallback === callback) {
-        this.onVideoFrameCallback = undefined;
-      }
-    };
   }
-  drawFrame = (frame) => {
-    if (!this.context) {
-      throw new Error("Context not initialized");
-    }
-    this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
-    this.context.drawImage(frame.canvas, 0, 0);
-    this.debugStats.framesRendered++;
-    this.drawDebugOverlay();
-    if (this.onVideoFrameCallback && this.canvas) {
-      this.onVideoFrameCallback(this.canvas);
-    }
-    Internals2.Log.trace({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Drew frame ${frame.timestamp.toFixed(3)}s`);
-  };
-  startAudioIterator = (startFromSecond) => {
-    if (!this.hasAudio())
-      return;
-    this.audioBufferIterator?.destroy();
-    try {
-      const iterator = makeAudioIterator(this.audioSink, startFromSecond);
-      this.audioBufferIterator = iterator;
-      this.runAudioIterator(startFromSecond, iterator);
-    } catch (error) {
-      if (this.isDisposalError()) {
-        return;
-      }
-      Internals2.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to start audio iterator", error);
-    }
-  };
-  drawDebugOverlay() {
+  drawDebugOverlay = () => {
     if (!this.debugOverlay)
       return;
     if (this.context && this.canvas) {
-      drawPreviewOverlay(this.context, this.debugStats, this.sharedAudioContext.state, this.sharedAudioContext.currentTime);
-    }
-  }
-  startVideoIterator = async (timeToSeek, nonce) => {
-    if (!this.canvasSink) {
-      return;
-    }
-    this.videoFrameIterator?.destroy();
-    const iterator = createVideoIterator(timeToSeek, this.canvasSink);
-    this.debugStats.videoIteratorsCreated++;
-    this.videoFrameIterator = iterator;
-    const delayHandle = this.bufferState?.delayPlayback();
-    const frameResult = await iterator.getNext();
-    delayHandle?.unblock();
-    if (iterator.isDestroyed()) {
-      return;
-    }
-    if (nonce !== this.currentSeekNonce) {
-      return;
-    }
-    if (this.videoFrameIterator.isDestroyed()) {
-      return;
-    }
-    if (frameResult.value) {
-      this.audioSyncAnchor = this.sharedAudioContext.currentTime - frameResult.value.timestamp;
-      this.drawFrame(frameResult.value);
-    } else {}
-  };
-  bufferingStartedAtMs = null;
-  minBufferingTimeoutMs = 500;
-  setBufferingState(isBuffering) {
-    if (this.isBuffering !== isBuffering) {
-      this.isBuffering = isBuffering;
-      if (isBuffering) {
-        this.bufferingStartedAtMs = performance.now();
-        this.onBufferingChangeCallback?.(true);
-      } else {
-        this.bufferingStartedAtMs = null;
-        this.onBufferingChangeCallback?.(false);
-      }
-    }
-  }
-  maybeResumeFromBuffering(currentBufferDuration) {
-    if (!this.isCurrentlyBuffering())
-      return;
-    const now = performance.now();
-    const bufferingDuration = now - this.bufferingStartedAtMs;
-    const minTimeElapsed = bufferingDuration >= this.minBufferingTimeoutMs;
-    const bufferHealthy = currentBufferDuration >= HEALTHY_BUFFER_THRESHOLD_SECONDS;
-    if (minTimeElapsed && bufferHealthy) {
-      Internals2.Log.trace({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Resuming from buffering after ${bufferingDuration}ms - buffer recovered`);
-      this.setBufferingState(false);
-    }
-  }
-  runAudioIterator = async (startFromSecond, audioIterator) => {
-    if (!this.hasAudio())
-      return;
-    try {
-      let totalBufferDuration = 0;
-      let isFirstBuffer = true;
-      audioIterator.setAudioIteratorStarted(true);
-      while (true) {
-        if (audioIterator.isDestroyed()) {
-          return;
-        }
-        const BUFFERING_TIMEOUT_MS = 50;
-        let result;
-        try {
-          result = await withTimeout(audioIterator.getNext(), BUFFERING_TIMEOUT_MS, "Iterator timeout");
-        } catch (error) {
-          if (error instanceof TimeoutError && !this.mediaEnded) {
-            this.setBufferingState(true);
-          }
-          await sleep(10);
-          continue;
-        }
-        if (result.done || !result.value) {
-          this.mediaEnded = true;
-          break;
-        }
-        const { buffer, timestamp, duration } = result.value;
-        totalBufferDuration += duration;
-        audioIterator.setAudioBufferHealth(Math.max(0, totalBufferDuration / this.playbackRate));
-        this.maybeResumeFromBuffering(totalBufferDuration / this.playbackRate);
-        if (this.playing) {
-          if (isFirstBuffer) {
-            this.audioSyncAnchor = this.sharedAudioContext.currentTime - timestamp;
-            isFirstBuffer = false;
-          }
-          if (timestamp < startFromSecond - AUDIO_BUFFER_TOLERANCE_THRESHOLD) {
-            continue;
-          }
-          this.scheduleAudioChunk(buffer, timestamp);
-        }
-        const playbackTime = this.getPlaybackTime();
-        if (playbackTime === null) {
-          continue;
-        }
-        if (timestamp - playbackTime >= 1) {
-          await new Promise((resolve) => {
-            const check = () => {
-              const currentPlaybackTime = this.getPlaybackTime();
-              if (currentPlaybackTime !== null && timestamp - currentPlaybackTime < 1) {
-                resolve();
-              } else {
-                requestAnimationFrame(check);
-              }
-            };
-            check();
-          });
-        }
-      }
-    } catch (error) {
-      if (this.isDisposalError()) {
-        return;
-      }
-      Internals2.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to run audio iterator", error);
+      drawPreviewOverlay({
+        context: this.context,
+        audioTime: this.sharedAudioContext.currentTime,
+        audioContextState: this.sharedAudioContext.state,
+        audioSyncAnchor: this.audioSyncAnchor,
+        audioIteratorManager: this.audioIteratorManager,
+        playing: this.playing,
+        videoIteratorManager: this.videoIteratorManager
+      });
     }
   };
 }
 
 // src/show-in-timeline.ts
 import { useMemo } from "react";
-import { Internals as Internals3, useVideoConfig } from "remotion";
+import { Internals as Internals4, useVideoConfig } from "remotion";
 var useLoopDisplay = ({
   loop,
   mediaDurationInSeconds,
@@ -776,7 +1128,7 @@ var useLoopDisplay = ({
     if (!loop || !mediaDurationInSeconds) {
       return;
     }
-    const durationInFrames = Internals3.calculateMediaDuration({
+    const durationInFrames = Internals4.calculateMediaDuration({
       mediaDurationInFrames: mediaDurationInSeconds * fps,
       playbackRate,
       trimAfter,
@@ -802,7 +1154,7 @@ var useLoopDisplay = ({
 
 // src/use-media-in-timeline.ts
 import { useContext, useEffect, useState } from "react";
-import { Internals as Internals4, useCurrentFrame } from "remotion";
+import { Internals as Internals5, useCurrentFrame } from "remotion";
 var useMediaInTimeline = ({
   volume,
   mediaVolume,
@@ -818,9 +1170,9 @@ var useMediaInTimeline = ({
   trimBefore,
   trimAfter
 }) => {
-  const parentSequence = useContext(Internals4.SequenceContext);
-  const startsAt = Internals4.useMediaStartsAt();
-  const { registerSequence, unregisterSequence } = useContext(Internals4.SequenceManager);
+  const parentSequence = useContext(Internals5.SequenceContext);
+  const startsAt = Internals5.useMediaStartsAt();
+  const { registerSequence, unregisterSequence } = useContext(Internals5.SequenceManager);
   const [sequenceId] = useState(() => String(Math.random()));
   const [mediaId] = useState(() => String(Math.random()));
   const frame = useCurrentFrame();
@@ -832,7 +1184,7 @@ var useMediaInTimeline = ({
     rootId,
     isStudio,
     finalDisplayName
-  } = Internals4.useBasicMediaInTimeline({
+  } = Internals5.useBasicMediaInTimeline({
     volume,
     mediaVolume,
     mediaType,
@@ -938,8 +1290,8 @@ var {
   warnAboutTooHighVolume,
   usePreload,
   SequenceContext
-} = Internals5;
-var NewAudioForPreview = ({
+} = Internals6;
+var AudioForPreviewAssertedShowing = ({
   src,
   playbackRate,
   logLevel,
@@ -988,6 +1340,8 @@ var NewAudioForPreview = ({
   currentTimeRef.current = currentTime;
   const preloadedSrc = usePreload(src);
   const parentSequence = useContext2(SequenceContext);
+  const isPremounting = Boolean(parentSequence?.premounting);
+  const isPostmounting = Boolean(parentSequence?.postmounting);
   const loopDisplay = useLoopDisplay({
     loop,
     mediaDurationInSeconds: videoConfig.durationInFrames,
@@ -1010,6 +1364,11 @@ var NewAudioForPreview = ({
     trimAfter,
     trimBefore
   });
+  const buffering = useContext2(Internals6.BufferingContextReact);
+  if (!buffering) {
+    throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
+  }
+  const isPlayerBuffering = Internals6.useIsPlayerBuffering(buffering);
   useEffect2(() => {
     if (!sharedAudioContext)
       return;
@@ -1028,7 +1387,10 @@ var NewAudioForPreview = ({
         playbackRate,
         audioStreamIndex: audioStreamIndex ?? 0,
         debugOverlay: false,
-        bufferState: buffer
+        bufferState: buffer,
+        isPostmounting,
+        isPremounting,
+        globalPlaybackRate
       });
       mediaPlayerRef.current = player;
       player.initialize(currentTimeRef.current).then((result) => {
@@ -1036,7 +1398,7 @@ var NewAudioForPreview = ({
           if (disallowFallbackToHtml5Audio) {
             throw new Error(`Unknown container format ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
           }
-          Internals5.Log.warn({ logLevel, tag: "@remotion/media" }, `Unknown container format for ${preloadedSrc} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Html5Audio>`);
+          Internals6.Log.warn({ logLevel, tag: "@remotion/media" }, `Unknown container format for ${preloadedSrc} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Html5Audio>`);
           setShouldFallbackToNativeAudio(true);
           return;
         }
@@ -1044,7 +1406,7 @@ var NewAudioForPreview = ({
           if (disallowFallbackToHtml5Audio) {
             throw new Error(`Network error fetching ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
           }
-          Internals5.Log.warn({ logLevel, tag: "@remotion/media" }, `Network error fetching ${preloadedSrc}, falling back to <Html5Audio>`);
+          Internals6.Log.warn({ logLevel, tag: "@remotion/media" }, `Network error fetching ${preloadedSrc}, falling back to <Html5Audio>`);
           setShouldFallbackToNativeAudio(true);
           return;
         }
@@ -1052,7 +1414,7 @@ var NewAudioForPreview = ({
           if (disallowFallbackToHtml5Audio) {
             throw new Error(`Cannot decode ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
           }
-          Internals5.Log.warn({ logLevel, tag: "@remotion/media" }, `Cannot decode ${preloadedSrc}, falling back to <Html5Audio>`);
+          Internals6.Log.warn({ logLevel, tag: "@remotion/media" }, `Cannot decode ${preloadedSrc}, falling back to <Html5Audio>`);
           setShouldFallbackToNativeAudio(true);
           return;
         }
@@ -1060,20 +1422,20 @@ var NewAudioForPreview = ({
           if (disallowFallbackToHtml5Audio) {
             throw new Error(`No video or audio tracks found for ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
           }
-          Internals5.Log.warn({ logLevel, tag: "@remotion/media" }, `No video or audio tracks found for ${preloadedSrc}, falling back to <Html5Audio>`);
+          Internals6.Log.warn({ logLevel, tag: "@remotion/media" }, `No video or audio tracks found for ${preloadedSrc}, falling back to <Html5Audio>`);
           setShouldFallbackToNativeAudio(true);
           return;
         }
         if (result.type === "success") {
           setMediaPlayerReady(true);
-          Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, `[NewAudioForPreview] MediaPlayer initialized successfully`);
+          Internals6.Log.trace({ logLevel, tag: "@remotion/media" }, `[AudioForPreview] MediaPlayer initialized successfully`);
         }
       }).catch((error) => {
-        Internals5.Log.error({ logLevel, tag: "@remotion/media" }, "[NewAudioForPreview] Failed to initialize MediaPlayer", error);
+        Internals6.Log.error({ logLevel, tag: "@remotion/media" }, "[AudioForPreview] Failed to initialize MediaPlayer", error);
         setShouldFallbackToNativeAudio(true);
       });
     } catch (error) {
-      Internals5.Log.error({ logLevel, tag: "@remotion/media" }, "[NewAudioForPreview] MediaPlayer initialization failed", error);
+      Internals6.Log.error({ logLevel, tag: "@remotion/media" }, "[AudioForPreview] MediaPlayer initialization failed", error);
       setShouldFallbackToNativeAudio(true);
     }
     return () => {
@@ -1082,7 +1444,7 @@ var NewAudioForPreview = ({
         delayHandleRef.current = null;
       }
       if (mediaPlayerRef.current) {
-        Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, `[NewAudioForPreview] Disposing MediaPlayer`);
+        Internals6.Log.trace({ logLevel, tag: "@remotion/media" }, `[AudioForPreview] Disposing MediaPlayer`);
         mediaPlayerRef.current.dispose();
         mediaPlayerRef.current = null;
       }
@@ -1101,42 +1463,28 @@ var NewAudioForPreview = ({
     videoConfig.fps,
     audioStreamIndex,
     disallowFallbackToHtml5Audio,
-    buffer
+    buffer,
+    isPremounting,
+    isPostmounting,
+    globalPlaybackRate
   ]);
   useEffect2(() => {
     const audioPlayer = mediaPlayerRef.current;
     if (!audioPlayer)
       return;
-    if (playing) {
-      audioPlayer.play().catch((error) => {
-        Internals5.Log.error({ logLevel, tag: "@remotion/media" }, "[NewAudioForPreview] Failed to play", error);
-      });
+    if (playing && !isPlayerBuffering) {
+      audioPlayer.play(currentTimeRef.current);
     } else {
       audioPlayer.pause();
     }
-  }, [playing, logLevel, mediaPlayerReady]);
+  }, [isPlayerBuffering, logLevel, playing]);
   useEffect2(() => {
     const audioPlayer = mediaPlayerRef.current;
     if (!audioPlayer || !mediaPlayerReady)
       return;
-    audioPlayer.seekTo(currentTime);
-    Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, `[NewAudioForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
+    audioPlayer.seekTo(currentTime).catch(() => {});
+    Internals6.Log.trace({ logLevel, tag: "@remotion/media" }, `[AudioForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
   }, [currentTime, logLevel, mediaPlayerReady]);
-  useEffect2(() => {
-    const audioPlayer = mediaPlayerRef.current;
-    if (!audioPlayer || !mediaPlayerReady)
-      return;
-    audioPlayer.onBufferingChange((newBufferingState) => {
-      if (newBufferingState && !delayHandleRef.current) {
-        delayHandleRef.current = buffer.delayPlayback();
-        Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, "[NewAudioForPreview] MediaPlayer buffering - blocking Remotion playback");
-      } else if (!newBufferingState && delayHandleRef.current) {
-        delayHandleRef.current.unblock();
-        delayHandleRef.current = null;
-        Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, "[NewAudioForPreview] MediaPlayer unbuffering - unblocking Remotion playback");
-      }
-    });
-  }, [mediaPlayerReady, buffer, logLevel]);
   const effectiveMuted = muted || mediaMuted || userPreferredVolume <= 0;
   useEffect2(() => {
     const audioPlayer = mediaPlayerRef.current;
@@ -1151,14 +1499,20 @@ var NewAudioForPreview = ({
     }
     audioPlayer.setVolume(userPreferredVolume);
   }, [userPreferredVolume, mediaPlayerReady]);
-  const effectivePlaybackRate = useMemo2(() => playbackRate * globalPlaybackRate, [playbackRate, globalPlaybackRate]);
   useEffect2(() => {
     const audioPlayer = mediaPlayerRef.current;
     if (!audioPlayer || !mediaPlayerReady) {
       return;
     }
-    audioPlayer.setPlaybackRate(effectivePlaybackRate);
-  }, [effectivePlaybackRate, mediaPlayerReady]);
+    audioPlayer.setPlaybackRate(playbackRate);
+  }, [playbackRate, mediaPlayerReady]);
+  useEffect2(() => {
+    const audioPlayer = mediaPlayerRef.current;
+    if (!audioPlayer || !mediaPlayerReady) {
+      return;
+    }
+    audioPlayer.setGlobalPlaybackRate(globalPlaybackRate);
+  }, [globalPlaybackRate, mediaPlayerReady]);
   useEffect2(() => {
     const audioPlayer = mediaPlayerRef.current;
     if (!audioPlayer || !mediaPlayerReady) {
@@ -1166,6 +1520,41 @@ var NewAudioForPreview = ({
     }
     audioPlayer.setFps(videoConfig.fps);
   }, [videoConfig.fps, mediaPlayerReady]);
+  useEffect2(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setTrimBefore(trimBefore);
+  }, [trimBefore, mediaPlayerReady]);
+  useEffect2(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setTrimAfter(trimAfter);
+  }, [trimAfter, mediaPlayerReady]);
+  useEffect2(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setLoop(loop);
+  }, [loop, mediaPlayerReady]);
+  useEffect2(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setIsPremounting(isPremounting);
+  }, [isPremounting, mediaPlayerReady]);
+  useEffect2(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setIsPostmounting(isPostmounting);
+  }, [isPostmounting, mediaPlayerReady]);
   if (shouldFallbackToNativeAudio && !disallowFallbackToHtml5Audio) {
     return /* @__PURE__ */ jsx(RemotionAudio, {
       src,
@@ -1206,7 +1595,34 @@ var AudioForPreview = ({
   fallbackHtml5AudioProps
 }) => {
   const preloadedSrc = usePreload(src);
-  return /* @__PURE__ */ jsx(NewAudioForPreview, {
+  const frame = useCurrentFrame2();
+  const videoConfig = useVideoConfig2();
+  const currentTime = frame / videoConfig.fps;
+  const showShow = useMemo2(() => {
+    return getTimeInSeconds({
+      unloopedTimeInSeconds: currentTime,
+      playbackRate: playbackRate ?? 1,
+      loop: loop ?? false,
+      trimBefore,
+      trimAfter,
+      mediaDurationInSeconds: Infinity,
+      fps: videoConfig.fps,
+      ifNoMediaDuration: "infinity",
+      src
+    }) !== null;
+  }, [
+    currentTime,
+    loop,
+    playbackRate,
+    src,
+    trimAfter,
+    trimBefore,
+    videoConfig.fps
+  ]);
+  if (!showShow) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(AudioForPreviewAssertedShowing, {
     audioStreamIndex: audioStreamIndex ?? 0,
     src: preloadedSrc,
     playbackRate: playbackRate ?? 1,
@@ -1231,7 +1647,7 @@ import { useContext as useContext3, useLayoutEffect, useMemo as useMemo3, useSta
 import {
   cancelRender as cancelRender2,
   Html5Audio,
-  Internals as Internals12,
+  Internals as Internals13,
   random,
   useCurrentFrame as useCurrentFrame3,
   useDelayRender,
@@ -1362,13 +1778,13 @@ var frameForVolumeProp = ({
 };
 
 // src/caches.ts
-import { cancelRender, Internals as Internals10 } from "remotion";
+import { cancelRender, Internals as Internals11 } from "remotion";
 
 // src/audio-extraction/audio-manager.ts
-import { Internals as Internals7 } from "remotion";
+import { Internals as Internals8 } from "remotion";
 
 // src/audio-extraction/audio-iterator.ts
-import { Internals as Internals6 } from "remotion";
+import { Internals as Internals7 } from "remotion";
 
 // src/audio-extraction/audio-cache.ts
 var makeAudioCache = () => {
@@ -1446,7 +1862,7 @@ var warnAboutMatroskaOnce = (src, logLevel) => {
     return;
   }
   warned[src] = true;
-  Internals6.Log.warn({ logLevel, tag: "@remotion/media" }, `Audio from ${src} will need to be read from the beginning. https://www.remotion.dev/docs/media/support#matroska-limitation`);
+  Internals7.Log.warn({ logLevel, tag: "@remotion/media" }, `Audio from ${src} will need to be read from the beginning. https://www.remotion.dev/docs/media/support#matroska-limitation`);
 };
 var makeAudioIterator2 = ({
   audioSampleSink,
@@ -1514,7 +1930,7 @@ var makeAudioIterator2 = ({
     if (openTimestamps.length > 0) {
       const first = openTimestamps[0];
       const last = openTimestamps[openTimestamps.length - 1];
-      Internals6.Log.verbose({ logLevel, tag: "@remotion/media" }, "Open audio samples for src", src, `${first.toFixed(3)}...${last.toFixed(3)}`);
+      Internals7.Log.verbose({ logLevel, tag: "@remotion/media" }, "Open audio samples for src", src, `${first.toFixed(3)}...${last.toFixed(3)}`);
     }
   };
   const getCacheStats = () => {
@@ -1611,7 +2027,7 @@ var makeAudioManager = () => {
       if (seenKeys.has(key)) {
         iterator.prepareForDeletion();
         iterators.splice(iterators.indexOf(iterator), 1);
-        Internals7.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted duplicate iterator for ${iterator.src}`);
+        Internals8.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted duplicate iterator for ${iterator.src}`);
       }
       seenKeys.add(key);
     }
@@ -1693,7 +2109,7 @@ var makeAudioManager = () => {
 };
 
 // src/video-extraction/keyframe-manager.ts
-import { Internals as Internals9 } from "remotion";
+import { Internals as Internals10 } from "remotion";
 
 // src/browser-can-use-webgl2.ts
 var browserCanUseWebGl2 = null;
@@ -1734,7 +2150,7 @@ import {
 } from "mediabunny";
 
 // src/video-extraction/keyframe-bank.ts
-import { Internals as Internals8 } from "remotion";
+import { Internals as Internals9 } from "remotion";
 var makeKeyframeBank = ({
   startTimestampInSeconds,
   endTimestampInSeconds,
@@ -1742,7 +2158,7 @@ var makeKeyframeBank = ({
   logLevel: parentLogLevel,
   src
 }) => {
-  Internals8.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
+  Internals9.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
   const frames = {};
   const frameTimestamps = [];
   let lastUsed = Date.now();
@@ -1769,7 +2185,7 @@ var makeKeyframeBank = ({
       }
     }
     if (deletedTimestamps.length > 0) {
-      Internals8.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${deletedTimestamps.length} frame${deletedTimestamps.length === 1 ? "" : "s"} ${renderTimestampRange(deletedTimestamps)} for src ${src} because it is lower than ${timestampInSeconds}. Remaining: ${renderTimestampRange(frameTimestamps)}`);
+      Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${deletedTimestamps.length} frame${deletedTimestamps.length === 1 ? "" : "s"} ${renderTimestampRange(deletedTimestamps)} for src ${src} because it is lower than ${timestampInSeconds}. Remaining: ${renderTimestampRange(frameTimestamps)}`);
     }
   };
   const hasDecodedEnoughForTimestamp = (timestamp) => {
@@ -1829,7 +2245,7 @@ var makeKeyframeBank = ({
     return await getFrameFromTimestamp(timestamp) !== null;
   };
   const prepareForDeletion = (logLevel) => {
-    Internals8.Log.verbose({ logLevel, tag: "@remotion/media" }, `Preparing for deletion of keyframe bank from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
+    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();
@@ -2022,10 +2438,10 @@ var makeKeyframeManager = () => {
         if (size === 0) {
           continue;
         }
-        Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Open frames for src ${src}: ${renderTimestampRange(timestamps)}`);
+        Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Open frames for src ${src}: ${renderTimestampRange(timestamps)}`);
       }
     }
-    Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Video cache stats: ${count} open frames, ${totalSize} bytes`);
+    Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Video cache stats: ${count} open frames, ${totalSize} bytes`);
   };
   const getCacheStats = async () => {
     let count = 0;
@@ -2074,7 +2490,7 @@ var makeKeyframeManager = () => {
     if (mostInThePastBank) {
       const { framesDeleted } = mostInThePastBank.prepareForDeletion(logLevel);
       delete sources[mostInThePastSrc][mostInThePastBank.startTimestampInSeconds];
-      Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${framesDeleted} frames for src ${mostInThePastSrc} from ${mostInThePastBank.startTimestampInSeconds}sec to ${mostInThePastBank.endTimestampInSeconds}sec to free up memory.`);
+      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.`);
     }
     return { finish: false };
   };
@@ -2086,7 +2502,7 @@ var makeKeyframeManager = () => {
       if (finish) {
         break;
       }
-      Internals9.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));
+      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();
     }
   };
@@ -2105,7 +2521,7 @@ var makeKeyframeManager = () => {
       const { endTimestampInSeconds, startTimestampInSeconds } = bank;
       if (endTimestampInSeconds < threshold) {
         bank.prepareForDeletion(logLevel);
-        Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `[Video] Cleared frames for src ${src} from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
+        Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `[Video] Cleared frames for src ${src} from ${startTimestampInSeconds}sec to ${endTimestampInSeconds}sec`);
         delete sources[src][startTimeInSeconds];
       } else {
         bank.deleteFramesBeforeTimestamp({
@@ -2149,7 +2565,7 @@ var makeKeyframeManager = () => {
     if (await (await existingBank).hasTimestampInSecond(timestamp)) {
       return existingBank;
     }
-    Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists but frame at time ${timestamp} does not exist anymore.`);
+    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({
@@ -2238,20 +2654,20 @@ var getUncachedMaxCacheSize = (logLevel) => {
     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}`));
     }
-    Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set using "mediaCacheSizeInBytes": ${(window.remotion_mediaCacheSizeInBytes / 1024 / 1024).toFixed(1)} MB`);
+    Internals11.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 (typeof window !== "undefined" && window.remotion_initialMemoryAvailable !== undefined && window.remotion_initialMemoryAvailable !== null) {
     const value = window.remotion_initialMemoryAvailable / 2;
     if (value < 500 * 1024 * 1024) {
-      Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on minimum value of 500MB (which is more than half of the available system memory!)`);
+      Internals11.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on minimum value of 500MB (which is more than half of the available system memory!)`);
       return 500 * 1024 * 1024;
     }
     if (value > 20000 * 1024 * 1024) {
-      Internals10.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)`);
+      Internals11.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;
     }
-    Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on available memory (50% of available memory): ${(value / 1024 / 1024).toFixed(1)} MB`);
+    Internals11.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;
@@ -2338,12 +2754,12 @@ var convertAudioData = ({
 };
 
 // src/get-sink.ts
-import { Internals as Internals11 } from "remotion";
+import { Internals as Internals12 } from "remotion";
 var sinkPromises = {};
 var getSink = (src, logLevel) => {
   let promise = sinkPromises[src];
   if (!promise) {
-    Internals11.Log.verbose({
+    Internals12.Log.verbose({
       logLevel,
       tag: "@remotion/media"
     }, `Sink for ${src} was not found, creating new sink`);
@@ -2836,10 +3252,10 @@ var AudioForRendering = ({
   trimBefore
 }) => {
   const frame = useCurrentFrame3();
-  const absoluteFrame = Internals12.useTimelinePosition();
-  const videoConfig = Internals12.useUnsafeVideoConfig();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext3(Internals12.RenderAssetManager);
-  const startsAt = Internals12.useMediaStartsAt();
+  const absoluteFrame = Internals13.useTimelinePosition();
+  const videoConfig = Internals13.useUnsafeVideoConfig();
+  const { registerRenderAsset, unregisterRenderAsset } = useContext3(Internals13.RenderAssetManager);
+  const startsAt = Internals13.useMediaStartsAt();
   const environment = useRemotionEnvironment();
   if (!videoConfig) {
     throw new Error("No video config found");
@@ -2850,7 +3266,7 @@ var AudioForRendering = ({
   const { fps } = videoConfig;
   const { delayRender, continueRender } = useDelayRender();
   const [replaceWithHtml5Audio, setReplaceWithHtml5Audio] = useState3(false);
-  const sequenceContext = useContext3(Internals12.SequenceContext);
+  const sequenceContext = useContext3(Internals13.SequenceContext);
   const id = useMemo3(() => `media-video-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
@@ -2895,7 +3311,7 @@ var AudioForRendering = ({
         if (disallowFallbackToHtml5Audio) {
           cancelRender2(new Error(`Unknown container format ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
         }
-        Internals12.Log.warn({
+        Internals13.Log.warn({
           logLevel: logLevel ?? window.remotion_logLevel,
           tag: "@remotion/media"
         }, `Unknown container format for ${src} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Html5Audio>`);
@@ -2906,7 +3322,7 @@ var AudioForRendering = ({
         if (disallowFallbackToHtml5Audio) {
           cancelRender2(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
         }
-        Internals12.Log.warn({
+        Internals13.Log.warn({
           logLevel: logLevel ?? window.remotion_logLevel,
           tag: "@remotion/media"
         }, `Cannot decode ${src}, falling back to <Html5Audio>`);
@@ -2920,7 +3336,7 @@ var AudioForRendering = ({
         if (disallowFallbackToHtml5Audio) {
           cancelRender2(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
         }
-        Internals12.Log.warn({
+        Internals13.Log.warn({
           logLevel: logLevel ?? window.remotion_logLevel,
           tag: "@remotion/media"
         }, `Network error fetching ${src}, falling back to <Html5Audio>`);
@@ -2936,12 +3352,12 @@ var AudioForRendering = ({
         frame,
         startsAt
       });
-      const volume = Internals12.evaluateVolume({
+      const volume = Internals13.evaluateVolume({
         volume: volumeProp,
         frame: volumePropsFrame,
         mediaVolume: 1
       });
-      Internals12.warnAboutTooHighVolume(volume);
+      Internals13.warnAboutTooHighVolume(volume);
       if (audio && volume > 0) {
         applyVolume(audio.data, volume);
         registerRenderAsset({
@@ -3014,7 +3430,7 @@ var AudioForRendering = ({
 
 // src/audio/audio.tsx
 import { jsx as jsx3 } from "react/jsx-runtime";
-var { validateMediaProps } = Internals13;
+var { validateMediaProps } = Internals14;
 var Audio = (props) => {
   const { name, stack, showInTimeline, ...otherProps } = props;
   const environment = useRemotionEnvironment2();
@@ -3033,10 +3449,10 @@ var Audio = (props) => {
     stack: stack ?? null
   });
 };
-Internals13.addSequenceStackTraces(Audio);
+Internals14.addSequenceStackTraces(Audio);
 
 // src/video/video.tsx
-import { Internals as Internals16, useRemotionEnvironment as useRemotionEnvironment4 } from "remotion";
+import { Internals as Internals17, useRemotionEnvironment as useRemotionEnvironment4 } from "remotion";
 
 // src/video/video-for-preview.tsx
 import {
@@ -3047,7 +3463,13 @@ import {
   useRef as useRef2,
   useState as useState4
 } from "react";
-import { Html5Video, Internals as Internals14, useBufferState as useBufferState2, useCurrentFrame as useCurrentFrame4 } from "remotion";
+import {
+  Html5Video,
+  Internals as Internals15,
+  useBufferState as useBufferState2,
+  useCurrentFrame as useCurrentFrame4,
+  useVideoConfig as useVideoConfig3
+} from "remotion";
 import { jsx as jsx4 } from "react/jsx-runtime";
 var {
   useUnsafeVideoConfig: useUnsafeVideoConfig2,
@@ -3061,8 +3483,8 @@ var {
   usePreload: usePreload2,
   SequenceContext: SequenceContext2,
   SequenceVisibilityToggleContext
-} = Internals14;
-var VideoForPreview = ({
+} = Internals15;
+var VideoForPreviewAssertedShowing = ({
   src: unpreloadedSrc,
   style,
   playbackRate,
@@ -3107,6 +3529,8 @@ var VideoForPreview = ({
   });
   warnAboutTooHighVolume2(userPreferredVolume);
   const parentSequence = useContext4(SequenceContext2);
+  const isPremounting = Boolean(parentSequence?.premounting);
+  const isPostmounting = Boolean(parentSequence?.postmounting);
   const loopDisplay = useLoopDisplay({
     loop,
     mediaDurationInSeconds,
@@ -3137,6 +3561,11 @@ var VideoForPreview = ({
   const currentTimeRef = useRef2(currentTime);
   currentTimeRef.current = currentTime;
   const preloadedSrc = usePreload2(src);
+  const buffering = useContext4(Internals15.BufferingContextReact);
+  if (!buffering) {
+    throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
+  }
+  const isPlayerBuffering = Internals15.useIsPlayerBuffering(buffering);
   useEffect3(() => {
     if (!canvasRef.current)
       return;
@@ -3157,7 +3586,10 @@ var VideoForPreview = ({
         playbackRate,
         audioStreamIndex,
         debugOverlay,
-        bufferState: buffer
+        bufferState: buffer,
+        isPremounting,
+        isPostmounting,
+        globalPlaybackRate
       });
       mediaPlayerRef.current = player;
       player.initialize(currentTimeRef.current).then((result) => {
@@ -3168,7 +3600,7 @@ var VideoForPreview = ({
           if (disallowFallbackToOffthreadVideo) {
             throw new Error(`Unknown container format ${preloadedSrc}, and 'disallowFallbackToOffthreadVideo' was set.`);
           }
-          Internals14.Log.warn({ logLevel, tag: "@remotion/media" }, `Unknown container format for ${preloadedSrc} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <OffthreadVideo>`);
+          Internals15.Log.warn({ logLevel, tag: "@remotion/media" }, `Unknown container format for ${preloadedSrc} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <OffthreadVideo>`);
           setShouldFallbackToNativeVideo(true);
           return;
         }
@@ -3176,7 +3608,7 @@ var VideoForPreview = ({
           if (disallowFallbackToOffthreadVideo) {
             throw new Error(`Network error fetching ${preloadedSrc}, and 'disallowFallbackToOffthreadVideo' was set.`);
           }
-          Internals14.Log.warn({ logLevel, tag: "@remotion/media" }, `Network error fetching ${preloadedSrc}, falling back to <OffthreadVideo>`);
+          Internals15.Log.warn({ logLevel, tag: "@remotion/media" }, `Network error fetching ${preloadedSrc}, falling back to <OffthreadVideo>`);
           setShouldFallbackToNativeVideo(true);
           return;
         }
@@ -3184,7 +3616,7 @@ var VideoForPreview = ({
           if (disallowFallbackToOffthreadVideo) {
             throw new Error(`Cannot decode ${preloadedSrc}, and 'disallowFallbackToOffthreadVideo' was set.`);
           }
-          Internals14.Log.warn({ logLevel, tag: "@remotion/media" }, `Cannot decode ${preloadedSrc}, falling back to <OffthreadVideo>`);
+          Internals15.Log.warn({ logLevel, tag: "@remotion/media" }, `Cannot decode ${preloadedSrc}, falling back to <OffthreadVideo>`);
           setShouldFallbackToNativeVideo(true);
           return;
         }
@@ -3192,7 +3624,7 @@ var VideoForPreview = ({
           if (disallowFallbackToOffthreadVideo) {
             throw new Error(`No video or audio tracks found for ${preloadedSrc}, and 'disallowFallbackToOffthreadVideo' was set.`);
           }
-          Internals14.Log.warn({ logLevel, tag: "@remotion/media" }, `No video or audio tracks found for ${preloadedSrc}, falling back to <OffthreadVideo>`);
+          Internals15.Log.warn({ logLevel, tag: "@remotion/media" }, `No video or audio tracks found for ${preloadedSrc}, falling back to <OffthreadVideo>`);
           setShouldFallbackToNativeVideo(true);
           return;
         }
@@ -3201,16 +3633,16 @@ var VideoForPreview = ({
           setMediaDurationInSeconds(result.durationInSeconds);
         }
       }).catch((error) => {
-        Internals14.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] Failed to initialize MediaPlayer", error);
+        Internals15.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] Failed to initialize MediaPlayer", error);
         setShouldFallbackToNativeVideo(true);
       });
     } catch (error) {
-      Internals14.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer initialization failed", error);
+      Internals15.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer initialization failed", error);
       setShouldFallbackToNativeVideo(true);
     }
     return () => {
       if (mediaPlayerRef.current) {
-        Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Disposing MediaPlayer`);
+        Internals15.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Disposing MediaPlayer`);
         mediaPlayerRef.current.dispose();
         mediaPlayerRef.current = null;
       }
@@ -3229,53 +3661,31 @@ var VideoForPreview = ({
     disallowFallbackToOffthreadVideo,
     audioStreamIndex,
     debugOverlay,
-    buffer
+    buffer,
+    isPremounting,
+    isPostmounting,
+    globalPlaybackRate
   ]);
   const classNameValue = useMemo4(() => {
-    return [Internals14.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals14.truthy).join(" ");
+    return [Internals15.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals15.truthy).join(" ");
   }, [className]);
   useEffect3(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer)
       return;
-    if (playing) {
-      mediaPlayer.play().catch((error) => {
-        Internals14.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] Failed to play", error);
-      });
+    if (playing && !isPlayerBuffering) {
+      mediaPlayer.play(currentTimeRef.current);
     } else {
       mediaPlayer.pause();
     }
-  }, [playing, logLevel, mediaPlayerReady]);
+  }, [isPlayerBuffering, playing, logLevel, mediaPlayerReady]);
   useLayoutEffect2(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady)
       return;
-    mediaPlayer.seekTo(currentTime);
-    Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
+    mediaPlayer.seekTo(currentTime).catch(() => {});
+    Internals15.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
   }, [currentTime, logLevel, mediaPlayerReady]);
-  useEffect3(() => {
-    const mediaPlayer = mediaPlayerRef.current;
-    if (!mediaPlayer || !mediaPlayerReady)
-      return;
-    let currentBlock = null;
-    const unsubscribe = mediaPlayer.onBufferingChange((newBufferingState) => {
-      if (newBufferingState && !currentBlock) {
-        currentBlock = buffer.delayPlayback();
-        Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer buffering - blocking Remotion playback");
-      } else if (!newBufferingState && currentBlock) {
-        currentBlock.unblock();
-        currentBlock = null;
-        Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer unbuffering - unblocking Remotion playback");
-      }
-    });
-    return () => {
-      unsubscribe();
-      if (currentBlock) {
-        currentBlock.unblock();
-        currentBlock = null;
-      }
-    };
-  }, [mediaPlayerReady, buffer, logLevel]);
   const effectiveMuted = isSequenceHidden || muted || mediaMuted || userPreferredVolume <= 0;
   useEffect3(() => {
     const mediaPlayer = mediaPlayerRef.current;
@@ -3297,14 +3707,20 @@ var VideoForPreview = ({
     }
     mediaPlayer.setDebugOverlay(debugOverlay);
   }, [debugOverlay, mediaPlayerReady]);
-  const effectivePlaybackRate = useMemo4(() => playbackRate * globalPlaybackRate, [playbackRate, globalPlaybackRate]);
   useEffect3(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
       return;
     }
-    mediaPlayer.setPlaybackRate(effectivePlaybackRate);
-  }, [effectivePlaybackRate, mediaPlayerReady]);
+    mediaPlayer.setPlaybackRate(playbackRate);
+  }, [playbackRate, mediaPlayerReady]);
+  useEffect3(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setGlobalPlaybackRate(globalPlaybackRate);
+  }, [globalPlaybackRate, mediaPlayerReady]);
   useEffect3(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
@@ -3312,6 +3728,20 @@ var VideoForPreview = ({
     }
     mediaPlayer.setLoop(loop);
   }, [loop, mediaPlayerReady]);
+  useEffect3(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setIsPremounting(isPremounting);
+  }, [isPremounting, mediaPlayerReady]);
+  useEffect3(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setIsPostmounting(isPostmounting);
+  }, [isPostmounting, mediaPlayerReady]);
   useEffect3(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
@@ -3321,14 +3751,25 @@ var VideoForPreview = ({
   }, [videoConfig.fps, mediaPlayerReady]);
   useEffect3(() => {
     const mediaPlayer = mediaPlayerRef.current;
-    if (!mediaPlayer || !mediaPlayerReady || !onVideoFrame) {
+    if (!mediaPlayer || !mediaPlayerReady) {
       return;
     }
-    const unsubscribe = mediaPlayer.onVideoFrame(onVideoFrame);
-    return () => {
-      unsubscribe();
-    };
+    mediaPlayer.setVideoFrameCallback(onVideoFrame ?? null);
   }, [onVideoFrame, mediaPlayerReady]);
+  useEffect3(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setTrimBefore(trimBefore);
+  }, [trimBefore, mediaPlayerReady]);
+  useEffect3(() => {
+    const mediaPlayer = mediaPlayerRef.current;
+    if (!mediaPlayer || !mediaPlayerReady) {
+      return;
+    }
+    mediaPlayer.setTrimAfter(trimAfter);
+  }, [trimAfter, mediaPlayerReady]);
   const actualStyle = useMemo4(() => {
     return {
       ...style,
@@ -3361,6 +3802,38 @@ var VideoForPreview = ({
     className: classNameValue
   });
 };
+var VideoForPreview = (props) => {
+  const frame = useCurrentFrame4();
+  const videoConfig = useVideoConfig3();
+  const currentTime = frame / videoConfig.fps;
+  const showShow = useMemo4(() => {
+    return getTimeInSeconds({
+      unloopedTimeInSeconds: currentTime,
+      playbackRate: props.playbackRate,
+      loop: props.loop,
+      trimBefore: props.trimBefore,
+      trimAfter: props.trimAfter,
+      mediaDurationInSeconds: Infinity,
+      fps: videoConfig.fps,
+      ifNoMediaDuration: "infinity",
+      src: props.src
+    }) !== null;
+  }, [
+    currentTime,
+    props.loop,
+    props.playbackRate,
+    props.src,
+    props.trimAfter,
+    props.trimBefore,
+    videoConfig.fps
+  ]);
+  if (!showShow) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx4(VideoForPreviewAssertedShowing, {
+    ...props
+  });
+};
 
 // src/video/video-for-rendering.tsx
 import {
@@ -3372,13 +3845,13 @@ import {
 } from "react";
 import {
   cancelRender as cancelRender3,
-  Internals as Internals15,
+  Internals as Internals16,
   Loop,
   random as random2,
   useCurrentFrame as useCurrentFrame5,
   useDelayRender as useDelayRender2,
   useRemotionEnvironment as useRemotionEnvironment3,
-  useVideoConfig as useVideoConfig2
+  useVideoConfig as useVideoConfig4
 } from "remotion";
 import { jsx as jsx5 } from "react/jsx-runtime";
 var VideoForRendering = ({
@@ -3407,11 +3880,11 @@ var VideoForRendering = ({
     throw new TypeError("No `src` was passed to <Video>.");
   }
   const frame = useCurrentFrame5();
-  const absoluteFrame = Internals15.useTimelinePosition();
-  const { fps } = useVideoConfig2();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext5(Internals15.RenderAssetManager);
-  const startsAt = Internals15.useMediaStartsAt();
-  const sequenceContext = useContext5(Internals15.SequenceContext);
+  const absoluteFrame = Internals16.useTimelinePosition();
+  const { fps } = useVideoConfig4();
+  const { registerRenderAsset, unregisterRenderAsset } = useContext5(Internals16.RenderAssetManager);
+  const startsAt = Internals16.useMediaStartsAt();
+  const sequenceContext = useContext5(Internals16.SequenceContext);
   const id = useMemo5(() => `media-video-${random2(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
@@ -3422,8 +3895,8 @@ var VideoForRendering = ({
   const { delayRender, continueRender } = useDelayRender2();
   const canvasRef = useRef3(null);
   const [replaceWithOffthreadVideo, setReplaceWithOffthreadVideo] = useState5(false);
-  const audioEnabled = Internals15.useAudioEnabled();
-  const videoEnabled = Internals15.useVideoEnabled();
+  const audioEnabled = Internals16.useAudioEnabled();
+  const videoEnabled = Internals16.useVideoEnabled();
   useLayoutEffect3(() => {
     if (!canvasRef.current) {
       return;
@@ -3466,7 +3939,7 @@ var VideoForRendering = ({
           cancelRender3(new Error(`Unknown container format ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
         }
         if (window.remotion_isMainTab) {
-          Internals15.Log.info({ logLevel, tag: "@remotion/media" }, `Unknown container format for ${src} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <OffthreadVideo>`);
+          Internals16.Log.info({ logLevel, tag: "@remotion/media" }, `Unknown container format for ${src} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <OffthreadVideo>`);
         }
         setReplaceWithOffthreadVideo({ durationInSeconds: null });
         return;
@@ -3476,7 +3949,7 @@ var VideoForRendering = ({
           cancelRender3(new Error(`Cannot decode ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
         }
         if (window.remotion_isMainTab) {
-          Internals15.Log.info({ logLevel, tag: "@remotion/media" }, `Cannot decode ${src}, falling back to <OffthreadVideo>`);
+          Internals16.Log.info({ logLevel, tag: "@remotion/media" }, `Cannot decode ${src}, falling back to <OffthreadVideo>`);
         }
         setReplaceWithOffthreadVideo({
           durationInSeconds: result.durationInSeconds
@@ -3488,7 +3961,7 @@ var VideoForRendering = ({
           cancelRender3(new Error(`Cannot decode alpha component for ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
         }
         if (window.remotion_isMainTab) {
-          Internals15.Log.info({ logLevel, tag: "@remotion/media" }, `Cannot decode alpha component for ${src}, falling back to <OffthreadVideo>`);
+          Internals16.Log.info({ logLevel, tag: "@remotion/media" }, `Cannot decode alpha component for ${src}, falling back to <OffthreadVideo>`);
         }
         setReplaceWithOffthreadVideo({
           durationInSeconds: result.durationInSeconds
@@ -3500,7 +3973,7 @@ var VideoForRendering = ({
           cancelRender3(new Error(`Cannot decode ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
         }
         if (window.remotion_isMainTab) {
-          Internals15.Log.info({ logLevel, tag: "@remotion/media" }, `Network error fetching ${src}, falling back to <OffthreadVideo>`);
+          Internals16.Log.info({ logLevel, tag: "@remotion/media" }, `Network error fetching ${src}, falling back to <OffthreadVideo>`);
         }
         setReplaceWithOffthreadVideo({ durationInSeconds: null });
         return;
@@ -3539,12 +4012,12 @@ var VideoForRendering = ({
         frame,
         startsAt
       });
-      const volume = Internals15.evaluateVolume({
+      const volume = Internals16.evaluateVolume({
         volume: volumeProp,
         frame: volumePropsFrame,
         mediaVolume: 1
       });
-      Internals15.warnAboutTooHighVolume(volume);
+      Internals16.warnAboutTooHighVolume(volume);
       if (audio && volume > 0) {
         applyVolume(audio.data, volume);
         registerRenderAsset({
@@ -3596,10 +4069,10 @@ var VideoForRendering = ({
     videoEnabled
   ]);
   const classNameValue = useMemo5(() => {
-    return [Internals15.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals15.truthy).join(" ");
+    return [Internals16.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals16.truthy).join(" ");
   }, [className]);
   if (replaceWithOffthreadVideo) {
-    const fallback = /* @__PURE__ */ jsx5(Internals15.InnerOffthreadVideo, {
+    const fallback = /* @__PURE__ */ jsx5(Internals16.InnerOffthreadVideo, {
       src,
       playbackRate: playbackRate ?? 1,
       muted: muted ?? false,
@@ -3639,7 +4112,7 @@ var VideoForRendering = ({
       }
       return /* @__PURE__ */ jsx5(Loop, {
         layout: "none",
-        durationInFrames: Internals15.calculateMediaDuration({
+        durationInFrames: Internals16.calculateMediaDuration({
           trimAfter: trimAfterValue,
           mediaDurationInFrames: replaceWithOffthreadVideo.durationInSeconds * fps,
           playbackRate,
@@ -3659,7 +4132,7 @@ var VideoForRendering = ({
 
 // src/video/video.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
-var { validateMediaTrimProps, resolveTrimProps, validateMediaProps: validateMediaProps2 } = Internals16;
+var { validateMediaTrimProps, resolveTrimProps, validateMediaProps: validateMediaProps2 } = Internals17;
 var InnerVideo = ({
   src,
   audioStreamIndex,
@@ -3796,7 +4269,7 @@ var Video = ({
     debugOverlay: debugOverlay ?? false
   });
 };
-Internals16.addSequenceStackTraces(Video);
+Internals17.addSequenceStackTraces(Video);
 // src/index.ts
 var experimental_Audio = Audio;
 var experimental_Video = Video;