@remotion/media 4.0.486 → 4.0.488

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

@@ -1,10 +1,11 @@
-import type { AudioBufferSink } from 'mediabunny';
+import type { AudioBufferSlice } from '../make-iterator-with-priming';
 export declare const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
 export declare const ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT = 0.1;
 export type QueuedNode = {
     node: AudioBufferSourceNode;
     timestamp: number;
     buffer: AudioBuffer;
+    sourceDurationInSeconds: number;
     scheduledTime: number;
     playbackRate: number;
     scheduledAtAnchor: number;
@@ -13,26 +14,16 @@ export type QueuedPeriod = {
     from: number;
     until: number;
 };
-export declare const makeAudioIterator: ({ startFromSecond, maximumTimestamp, audioSink, loop, playbackRate, sequenceDurationInSeconds, unscheduleAudioNode, }: {
+export type MakeAudioIteratorOptions = {
     startFromSecond: number;
-    maximumTimestamp: number;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
-    audioSink: AudioBufferSink;
-    loop: boolean;
-    playbackRate: number;
-    sequenceDurationInSeconds: number;
+    iterator: AsyncGenerator<AudioBufferSlice, void, unknown>;
     unscheduleAudioNode: (node: AudioBufferSourceNode) => void;
-}) => {
+};
+export declare const makeAudioIterator: ({ startFromSecond, iterator, unscheduleAudioNode, }: MakeAudioIteratorOptions) => {
     destroy: () => void;
-    getNextFn: () => Promise<IteratorResult<import("../make-iterator-with-priming").BufferWithMediaTimestamp, void>>;
+    getNextFn: () => Promise<IteratorResult<AudioBufferSlice, void>>;
     isDestroyed: () => boolean;
-    addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, scheduledAtAnchor, }: {
-        node: AudioBufferSourceNode;
-        timestamp: number;
-        buffer: AudioBuffer;
-        scheduledTime: number;
-        scheduledAtAnchor: number;
-    }) => void;
+    addQueuedAudioNode: (queuedNode: QueuedNode) => void;
     guessNextTimestamp: () => number;
     getQueuedPeriod: () => {
         from: number;

package/dist/audio/get-scheduled-time.d.ts

@@ -4,15 +4,15 @@ export declare const getScheduledTime: ({ mediaTimestamp, targetTime, currentTim
     currentTime: number;
     sequenceStartTime: number;
 }) => number;
-export declare const getDurationOfNode: ({ bufferDuration, loopSegmentMediaEndTimestamp, offset, originalUnloopedMediaTimestamp, }: {
-    bufferDuration: number;
-    loopSegmentMediaEndTimestamp: number;
+export declare const getDurationOfNode: ({ sourceDurationInSeconds, sourceOffsetInSeconds, offset, }: {
+    sourceDurationInSeconds: number;
+    sourceOffsetInSeconds: number;
     offset: number;
-    originalUnloopedMediaTimestamp: number;
 }) => number;
-export declare const getTrimStartForAudioNode: ({ mediaTimestamp, targetTime, sequenceStartTime, combinedPlaybackRate, }: {
+export declare const getTrimStartForAudioNode: ({ mediaTimestamp, targetTime, sequenceStartTime, combinedPlaybackRate, sourceStartOffsetInSeconds, }: {
     mediaTimestamp: number;
     targetTime: number;
     sequenceStartTime: number;
     combinedPlaybackRate: number;
+    sourceStartOffsetInSeconds: number;
 }) => number;

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

@@ -1,10 +1,19 @@
 import { type InputAudioTrack } from 'mediabunny';
 import { type ScheduleAudioNodeResult } from 'remotion';
 import type { DelayPlaybackIfNotPremounting } from './delay-playback-if-not-premounting';
-import type { BufferWithMediaTimestamp } from './make-iterator-with-priming';
+import { type AudioBufferSlice } from './make-iterator-with-priming';
 import type { Nonce } from './nonce-manager';
 import type { SharedAudioContextForMediaPlayer } from './shared-audio-context-for-media-player';
-type ScheduleAudioNode = (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number) => ScheduleAudioNodeResult;
+type ScheduleAudioNode = (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => ScheduleAudioNodeResult;
+export type AudioIteratorAnchor = {
+    unloopedStartInSeconds: number;
+    mediaStartInSeconds: number;
+};
+export declare const anchorToContinuousTime: ({ anchor, unloopedTimeInSeconds, playbackRate, }: {
+    anchor: AudioIteratorAnchor;
+    unloopedTimeInSeconds: number;
+    playbackRate: number;
+}) => number;
 export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getSequenceEndTimestamp, getSequenceDurationInSeconds, getMediaEndTimestamp, getStartTime, initialMuted, drawDebugOverlay, initialPlaybackRate, initialTrimBefore, initialTrimAfter, initialSequenceOffset, initialSequenceDurationInFrames, initialLoop, initialFps, }: {
     audioTrack: InputAudioTrack;
     delayPlaybackHandleIfNotPremounting: () => DelayPlaybackIfNotPremounting;
@@ -23,8 +32,9 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
     initialLoop: boolean;
     initialFps: number;
 }) => {
-    startAudioIterator: ({ nonce, playbackRate, startFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
+    startAudioIterator: ({ nonce, playbackRate, startFromSecond, unloopedStartFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
         startFromSecond: number;
+        unloopedStartFromSecond: number;
         nonce: Nonce;
         playbackRate: number;
         scheduleAudioNode: ScheduleAudioNode;
@@ -36,26 +46,23 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
     }) => void;
     getAudioBufferIterator: () => {
         destroy: () => void;
-        getNextFn: () => Promise<IteratorResult<BufferWithMediaTimestamp, void>>;
+        getNextFn: () => Promise<IteratorResult<AudioBufferSlice, void>>;
         isDestroyed: () => boolean;
-        addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, scheduledAtAnchor, }: {
-            node: AudioBufferSourceNode;
-            timestamp: number;
-            buffer: AudioBuffer;
-            scheduledTime: number;
-            scheduledAtAnchor: number;
-        }) => void;
+        addQueuedAudioNode: (queuedNode: import("./audio/audio-preview-iterator").QueuedNode) => void;
         guessNextTimestamp: () => number;
         getQueuedPeriod: () => {
             from: number;
             until: number;
         } | null;
     } | null;
+    getCurrentAnchor: () => AudioIteratorAnchor | null;
     destroyIterator: () => void;
-    seek: ({ newTime, nonce, playbackRate, scheduleAudioNode, getTargetTime, logLevel, loop, trimBefore, trimAfter, sequenceOffset, sequenceDurationInFrames, fps, getAudioContextCurrentTimeMockedInTest, }: {
+    seek: ({ newTime, unloopedNewTime, nonce, playbackRate, localPlaybackRate, scheduleAudioNode, getTargetTime, logLevel, loop, trimBefore, trimAfter, sequenceOffset, sequenceDurationInFrames, fps, getAudioContextCurrentTimeMockedInTest, }: {
         newTime: number;
+        unloopedNewTime: number;
         nonce: Nonce;
         playbackRate: number;
+        localPlaybackRate: number;
         scheduleAudioNode: ScheduleAudioNode;
         getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
         logLevel: "error" | "info" | "trace" | "verbose" | "warn";
@@ -71,13 +78,15 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
     getTotalAudioScheduledInSeconds: () => number;
     setMuted: (newMuted: boolean) => void;
     setVolume: (volume: number) => void;
-    scheduleAudioChunk: ({ buffer, mediaTimestamp, originalUnloopedMediaTimestamp, playbackRate, scheduleAudioNode, logLevel, }: {
+    scheduleAudioChunk: ({ buffer, mediaTimestamp, originalUnloopedMediaTimestamp, sourceOffsetInSeconds, sourceDurationInSeconds, playbackRate, scheduleAudioNode, logLevel, }: {
         buffer: AudioBuffer;
         mediaTimestamp: number;
         playbackRate: number;
         scheduleAudioNode: ScheduleAudioNode;
         logLevel: "error" | "info" | "trace" | "verbose" | "warn";
         originalUnloopedMediaTimestamp: number;
+        sourceOffsetInSeconds: number;
+        sourceDurationInSeconds: number;
     }) => void;
     waitForNScheduledNodes: (n: number) => Promise<void>;
 };

package/dist/debug-overlay/preview-overlay.d.ts

@@ -7,11 +7,12 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
     } | null;
     playing: boolean;
     audioIteratorManager: {
-        startAudioIterator: ({ nonce, playbackRate, startFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
+        startAudioIterator: ({ nonce, playbackRate, startFromSecond, unloopedStartFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
             startFromSecond: number;
+            unloopedStartFromSecond: number;
             nonce: import("../nonce-manager").Nonce;
             playbackRate: number;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number) => import("remotion").ScheduleAudioNodeResult;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => import("remotion").ScheduleAudioNodeResult;
             getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
             logLevel: "error" | "info" | "trace" | "verbose" | "warn";
             loop: boolean;
@@ -20,27 +21,24 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
         }) => void;
         getAudioBufferIterator: () => {
             destroy: () => void;
-            getNextFn: () => Promise<IteratorResult<import("../make-iterator-with-priming").BufferWithMediaTimestamp, void>>;
+            getNextFn: () => Promise<IteratorResult<import("../make-iterator-with-priming").AudioBufferSlice, void>>;
             isDestroyed: () => boolean;
-            addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, scheduledAtAnchor, }: {
-                node: AudioBufferSourceNode;
-                timestamp: number;
-                buffer: AudioBuffer;
-                scheduledTime: number;
-                scheduledAtAnchor: number;
-            }) => void;
+            addQueuedAudioNode: (queuedNode: import("../audio/audio-preview-iterator").QueuedNode) => void;
             guessNextTimestamp: () => number;
             getQueuedPeriod: () => {
                 from: number;
                 until: number;
             } | null;
         } | null;
+        getCurrentAnchor: () => import("../audio-iterator-manager").AudioIteratorAnchor | null;
         destroyIterator: () => void;
-        seek: ({ newTime, nonce, playbackRate, scheduleAudioNode, getTargetTime, logLevel, loop, trimBefore, trimAfter, sequenceOffset, sequenceDurationInFrames, fps, getAudioContextCurrentTimeMockedInTest, }: {
+        seek: ({ newTime, unloopedNewTime, nonce, playbackRate, localPlaybackRate, scheduleAudioNode, getTargetTime, logLevel, loop, trimBefore, trimAfter, sequenceOffset, sequenceDurationInFrames, fps, getAudioContextCurrentTimeMockedInTest, }: {
             newTime: number;
+            unloopedNewTime: number;
             nonce: import("../nonce-manager").Nonce;
             playbackRate: number;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number) => import("remotion").ScheduleAudioNodeResult;
+            localPlaybackRate: number;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => import("remotion").ScheduleAudioNodeResult;
             getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
             logLevel: "error" | "info" | "trace" | "verbose" | "warn";
             loop: boolean;
@@ -55,13 +53,15 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
         getTotalAudioScheduledInSeconds: () => number;
         setMuted: (newMuted: boolean) => void;
         setVolume: (volume: number) => void;
-        scheduleAudioChunk: ({ buffer, mediaTimestamp, originalUnloopedMediaTimestamp, playbackRate, scheduleAudioNode, logLevel, }: {
+        scheduleAudioChunk: ({ buffer, mediaTimestamp, originalUnloopedMediaTimestamp, sourceOffsetInSeconds, sourceDurationInSeconds, playbackRate, scheduleAudioNode, logLevel, }: {
             buffer: AudioBuffer;
             mediaTimestamp: number;
             playbackRate: number;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number) => import("remotion").ScheduleAudioNodeResult;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => import("remotion").ScheduleAudioNodeResult;
             logLevel: "error" | "info" | "trace" | "verbose" | "warn";
             originalUnloopedMediaTimestamp: number;
+            sourceOffsetInSeconds: number;
+            sourceDurationInSeconds: number;
         }) => void;
         waitForNScheduledNodes: (n: number) => Promise<void>;
     } | null;

package/dist/esm/index.mjs

@@ -146,97 +146,21 @@ import {
 } from "mediabunny";
 import { Internals as Internals3 } from "remotion";
 
-// src/make-iterator-with-priming.ts
-var AUDIO_PRIMING_SECONDS = 0.5;
-async function* makeIteratorWithPrimingInner(audioSink, timeToSeek, maximumTimestamp) {
-  const primingStart = Math.max(0, timeToSeek - AUDIO_PRIMING_SECONDS);
-  const iterator = audioSink.buffers(primingStart, maximumTimestamp);
-  for await (const buffer of iterator) {
-    if (buffer.timestamp + buffer.duration <= timeToSeek) {
-      continue;
-    }
-    yield {
-      buffer,
-      timestamp: buffer.timestamp
-    };
-  }
-}
-async function* makeLoopingIterator({
-  audioSink,
-  segmentStartInSeconds,
-  segmentEndInSeconds,
-  playbackRate,
-  sequenceDurationInSeconds
-}) {
-  const duration = segmentEndInSeconds - segmentStartInSeconds;
-  let iteration = 0;
-  let broken = false;
-  while (true) {
-    for await (const item of makeIteratorWithPrimingInner(audioSink, segmentStartInSeconds, segmentEndInSeconds)) {
-      const timestamp = item.timestamp + iteration * duration;
-      const endTimestamp = duration * iteration + (item.timestamp - segmentStartInSeconds + item.buffer.duration);
-      if (endTimestamp > sequenceDurationInSeconds * playbackRate) {
-        broken = true;
-        break;
-      }
-      yield {
-        buffer: item.buffer,
-        timestamp
-      };
-    }
-    if (broken) {
-      break;
-    }
-    iteration++;
-  }
-}
-var makeIteratorWithPriming = ({
-  audioSink,
-  timeToSeek,
-  maximumTimestamp,
-  loop,
-  playbackRate,
-  sequenceDurationInSeconds
-}) => {
-  if (loop) {
-    return makeLoopingIterator({
-      audioSink,
-      segmentStartInSeconds: timeToSeek,
-      segmentEndInSeconds: maximumTimestamp,
-      playbackRate,
-      sequenceDurationInSeconds
-    });
-  }
-  return makeIteratorWithPrimingInner(audioSink, timeToSeek, maximumTimestamp);
-};
-
 // src/audio/audio-preview-iterator.ts
 var ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT = 0.1;
 var makeAudioIterator = ({
   startFromSecond,
-  maximumTimestamp,
-  audioSink,
-  loop,
-  playbackRate,
-  sequenceDurationInSeconds,
+  iterator,
   unscheduleAudioNode
 }) => {
   let destroyed = false;
-  const iterator = makeIteratorWithPriming({
-    audioSink,
-    timeToSeek: startFromSecond,
-    maximumTimestamp,
-    loop,
-    playbackRate,
-    sequenceDurationInSeconds
-  });
   const queuedAudioNodes = [];
   let mostRecentTimestamp = -Infinity;
   const cleanupAudioQueue = () => {
-    for (const node of queuedAudioNodes) {
-      unscheduleAudioNode(node.node);
+    for (const { node } of queuedAudioNodes) {
+      unscheduleAudioNode(node);
       try {
-        node.node.stop();
+        node.stop();
       } catch {}
     }
     queuedAudioNodes.length = 0;
@@ -244,7 +168,7 @@ var makeAudioIterator = ({
   const getNextFn = async () => {
     const next = await iterator.next();
     if (next.value) {
-      mostRecentTimestamp = Math.max(mostRecentTimestamp, next.value.timestamp + next.value.buffer.duration);
+      mostRecentTimestamp = Math.max(mostRecentTimestamp, next.value.timelineTimestamp + next.value.sourceDurationInSeconds);
     }
     return next;
   };
@@ -260,21 +184,8 @@ var makeAudioIterator = ({
     isDestroyed: () => {
       return destroyed;
     },
-    addQueuedAudioNode: ({
-      node,
-      timestamp,
-      buffer,
-      scheduledTime,
-      scheduledAtAnchor
-    }) => {
-      queuedAudioNodes.push({
-        node,
-        timestamp,
-        buffer,
-        scheduledTime,
-        playbackRate,
-        scheduledAtAnchor
-      });
+    addQueuedAudioNode: (queuedNode) => {
+      queuedAudioNodes.push(queuedNode);
     },
     guessNextTimestamp: () => {
       return !Number.isFinite(mostRecentTimestamp) ? startFromSecond : mostRecentTimestamp;
@@ -283,7 +194,7 @@ var makeAudioIterator = ({
       let until = -Infinity;
       let from = Infinity;
       for (const node of queuedAudioNodes) {
-        until = Math.max(until, node.timestamp + node.buffer.duration);
+        until = Math.max(until, node.timestamp + node.sourceDurationInSeconds);
         from = Math.min(from, node.timestamp);
       }
       if (!Number.isFinite(from) || !Number.isFinite(until)) {
@@ -318,27 +229,23 @@ var getScheduledTime = ({
   return scheduledTime;
 };
 var getDurationOfNode = ({
-  bufferDuration,
-  loopSegmentMediaEndTimestamp,
-  offset,
-  originalUnloopedMediaTimestamp
+  sourceDurationInSeconds,
+  sourceOffsetInSeconds,
+  offset
 }) => {
-  const originalUnloopedMediaEndTime = originalUnloopedMediaTimestamp + bufferDuration;
-  const needsTrimEnd = originalUnloopedMediaEndTime > loopSegmentMediaEndTimestamp;
-  const durationMinusOffset = bufferDuration - offset;
-  const duration = needsTrimEnd ? durationMinusOffset - Math.max(0, originalUnloopedMediaEndTime - loopSegmentMediaEndTimestamp) : durationMinusOffset;
-  return duration;
+  return Math.max(0, sourceDurationInSeconds - (offset - sourceOffsetInSeconds));
 };
 var getTrimStartForAudioNode = ({
   mediaTimestamp,
   targetTime,
   sequenceStartTime,
-  combinedPlaybackRate
+  combinedPlaybackRate,
+  sourceStartOffsetInSeconds
 }) => {
   const needsTrimStart = mediaTimestamp < sequenceStartTime;
   const offsetBecauseOfTrim = needsTrimStart ? sequenceStartTime - mediaTimestamp : 0;
   const offsetBecauseOfTooLate = targetTime < 0 ? -targetTime * combinedPlaybackRate : 0;
-  return offsetBecauseOfTrim + offsetBecauseOfTooLate;
+  return sourceStartOffsetInSeconds + offsetBecauseOfTrim + offsetBecauseOfTooLate;
 };
 
 // src/audio/sort-by-priority.ts
@@ -442,7 +349,79 @@ var waitForTurn = ({
   processNext();
 };
 
+// src/make-iterator-with-priming.ts
+var AUDIO_PRIMING_SECONDS = 0.5;
+async function* makeIteratorWithPriming({
+  audioSink,
+  timeToSeek,
+  maximumTimestamp
+}) {
+  const primingStart = Math.max(0, timeToSeek - AUDIO_PRIMING_SECONDS);
+  const iterator = audioSink.buffers(primingStart, maximumTimestamp);
+  for await (const buffer of iterator) {
+    const sourceStart = Math.max(buffer.timestamp, timeToSeek);
+    const sourceEnd = Math.min(buffer.timestamp + buffer.duration, maximumTimestamp);
+    if (sourceEnd <= sourceStart) {
+      continue;
+    }
+    yield {
+      buffer,
+      timelineTimestamp: sourceStart,
+      sourceOffsetInSeconds: sourceStart - buffer.timestamp,
+      sourceDurationInSeconds: sourceEnd - sourceStart
+    };
+  }
+}
+async function* makeLoopingIterator({
+  audioSink,
+  seekTimeInSeconds,
+  loopStartInSeconds,
+  segmentEndInSeconds,
+  maximumContinuousTimestamp
+}) {
+  if (segmentEndInSeconds <= loopStartInSeconds) {
+    throw new Error(`Cannot loop audio over an empty range (${loopStartInSeconds} to ${segmentEndInSeconds})`);
+  }
+  let passStartInSeconds = seekTimeInSeconds;
+  let passBaseTimestamp = seekTimeInSeconds;
+  while (true) {
+    let yieldedInPass = false;
+    for await (const item of makeIteratorWithPriming({
+      audioSink,
+      timeToSeek: passStartInSeconds,
+      maximumTimestamp: segmentEndInSeconds
+    })) {
+      yieldedInPass = true;
+      const timelineTimestamp = passBaseTimestamp + (item.timelineTimestamp - passStartInSeconds);
+      const sourceDurationInSeconds = Math.min(item.sourceDurationInSeconds, maximumContinuousTimestamp - timelineTimestamp);
+      if (sourceDurationInSeconds <= 0) {
+        return;
+      }
+      yield {
+        ...item,
+        timelineTimestamp,
+        sourceDurationInSeconds
+      };
+      if (timelineTimestamp + sourceDurationInSeconds >= maximumContinuousTimestamp) {
+        return;
+      }
+    }
+    if (!yieldedInPass) {
+      throw new Error(`Audio loop pass from ${passStartInSeconds} to ${segmentEndInSeconds} yielded no buffers`);
+    }
+    passBaseTimestamp += segmentEndInSeconds - passStartInSeconds;
+    passStartInSeconds = loopStartInSeconds;
+  }
+}
+
 // src/audio-iterator-manager.ts
+var anchorToContinuousTime = ({
+  anchor,
+  unloopedTimeInSeconds,
+  playbackRate
+}) => {
+  return anchor.mediaStartInSeconds + (unloopedTimeInSeconds - anchor.unloopedStartInSeconds) * playbackRate;
+};
 var audioIteratorManager = ({
   audioTrack,
   delayPlaybackHandleIfNotPremounting,
@@ -477,6 +456,7 @@ var audioIteratorManager = ({
   gainNode.connect(sharedAudioContext.gainNode);
   const audioSink = new AudioBufferSink(audioTrack);
   let audioBufferIterator = null;
+  let currentAnchor = null;
   let audioIteratorsCreated = 0;
   let totalAudioScheduledInSeconds = 0;
   let currentDelayHandle = null;
@@ -509,6 +489,8 @@ var audioIteratorManager = ({
     buffer,
     mediaTimestamp,
     originalUnloopedMediaTimestamp,
+    sourceOffsetInSeconds,
+    sourceDurationInSeconds,
     playbackRate,
     scheduleAudioNode,
     logLevel
@@ -523,7 +505,7 @@ var audioIteratorManager = ({
     node.buffer = buffer;
     node.playbackRate.value = playbackRate;
     node.connect(gainNode);
-    const started = scheduleAudioNode(node, mediaTimestamp, originalUnloopedMediaTimestamp);
+    const started = scheduleAudioNode(node, mediaTimestamp, originalUnloopedMediaTimestamp, sourceOffsetInSeconds, sourceDurationInSeconds);
     if (started.type === "not-started") {
       Internals3.Log.verbose({ logLevel, tag: "audio-scheduling" }, "not started, disconnected: %s %s", mediaTimestamp.toFixed(3), buffer.duration.toFixed(3));
       node.disconnect();
@@ -533,7 +515,9 @@ var audioIteratorManager = ({
       node,
       timestamp: mediaTimestamp,
       buffer,
+      sourceDurationInSeconds,
       scheduledTime: started.scheduledTime,
+      playbackRate,
       scheduledAtAnchor: sharedAudioContext.audioSyncAnchor.value
     });
   };
@@ -548,22 +532,24 @@ var audioIteratorManager = ({
     }
     const startTime = getStartTime();
     const sequenceEndTime = getSequenceEndTimestamp();
-    if (buffer.timestamp + buffer.buffer.duration <= startTime) {
+    if (buffer.timelineTimestamp + buffer.sourceDurationInSeconds <= startTime) {
       return;
     }
-    if (buffer.timestamp >= sequenceEndTime) {
+    if (buffer.timelineTimestamp >= sequenceEndTime) {
       return;
     }
-    const scheduledStart = Math.max(buffer.timestamp, startTime);
-    const scheduledEnd = Math.min(buffer.timestamp + buffer.buffer.duration, sequenceEndTime);
+    const scheduledStart = Math.max(buffer.timelineTimestamp, startTime);
+    const scheduledEnd = Math.min(buffer.timelineTimestamp + buffer.sourceDurationInSeconds, sequenceEndTime);
     totalAudioScheduledInSeconds += Math.max(0, scheduledEnd - scheduledStart);
     scheduleAudioChunk({
       buffer: buffer.buffer.buffer,
-      mediaTimestamp: buffer.timestamp,
+      mediaTimestamp: buffer.timelineTimestamp,
       playbackRate,
       scheduleAudioNode,
       logLevel,
-      originalUnloopedMediaTimestamp: buffer.buffer.timestamp
+      originalUnloopedMediaTimestamp: buffer.buffer.timestamp,
+      sourceOffsetInSeconds: buffer.sourceOffsetInSeconds,
+      sourceDurationInSeconds: buffer.sourceDurationInSeconds
     });
     drawDebugOverlay();
   };
@@ -611,7 +597,7 @@ var audioIteratorManager = ({
           onDone();
           return;
         }
-        onScheduled(result.value.timestamp);
+        onScheduled(result.value.timelineTimestamp);
         notifyNodeScheduled();
         onAudioChunk({
           buffer: result.value,
@@ -651,6 +637,7 @@ var audioIteratorManager = ({
     nonce,
     playbackRate,
     startFromSecond,
+    unloopedStartFromSecond,
     scheduleAudioNode,
     getTargetTime,
     logLevel,
@@ -669,14 +656,25 @@ var audioIteratorManager = ({
     unblockCurrentDelayHandle();
     const delayHandle = delayPlaybackHandleIfNotPremounting();
     currentDelayHandle = delayHandle;
+    currentAnchor = {
+      unloopedStartInSeconds: unloopedStartFromSecond,
+      mediaStartInSeconds: startFromSecond
+    };
+    const maximumContinuousTimestamp = startFromSecond + getSequenceDurationInSeconds() * playbackRate;
+    const source = loop ? makeLoopingIterator({
+      audioSink,
+      seekTimeInSeconds: startFromSecond,
+      loopStartInSeconds: getStartTime(),
+      segmentEndInSeconds: maximumTimestamp,
+      maximumContinuousTimestamp
+    }) : makeIteratorWithPriming({
+      audioSink,
+      timeToSeek: startFromSecond,
+      maximumTimestamp
+    });
     const iterator = makeAudioIterator({
       startFromSecond,
-      maximumTimestamp,
-      audioSink,
-      logLevel,
-      loop,
-      playbackRate,
-      sequenceDurationInSeconds: getSequenceDurationInSeconds(),
+      iterator: source,
       unscheduleAudioNode
     });
     audioIteratorsCreated++;
@@ -707,8 +705,10 @@ var audioIteratorManager = ({
   };
   const seek = ({
     newTime,
+    unloopedNewTime,
     nonce,
     playbackRate,
+    localPlaybackRate,
     scheduleAudioNode,
     getTargetTime,
     logLevel,
@@ -740,18 +740,23 @@ var audioIteratorManager = ({
       return;
     }
     if (audioBufferIterator && !audioBufferIterator.isDestroyed()) {
+      const timeToCheck = loop && currentAnchor ? anchorToContinuousTime({
+        anchor: currentAnchor,
+        unloopedTimeInSeconds: unloopedNewTime,
+        playbackRate: localPlaybackRate
+      }) : newTime;
       const queuedPeriod = audioBufferIterator.getQueuedPeriod();
       const queuedPeriodMinusLatency = queuedPeriod ? {
         from: queuedPeriod.from - ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT - sharedAudioContext.audioContext.baseLatency - sharedAudioContext.audioContext.outputLatency,
         until: queuedPeriod.until
       } : null;
-      const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, queuedPeriodMinusLatency);
+      const currentTimeIsAlreadyQueued = isAlreadyQueued(timeToCheck, queuedPeriodMinusLatency);
       if (currentTimeIsAlreadyQueued) {
         processNext();
         return;
       }
       const currentIteratorTimestamp = audioBufferIterator.guessNextTimestamp();
-      if (currentIteratorTimestamp < newTime && Math.abs(currentIteratorTimestamp - newTime) < 1) {
+      if (currentIteratorTimestamp < timeToCheck && Math.abs(currentIteratorTimestamp - timeToCheck) < 1) {
         processNext();
         return;
       }
@@ -760,6 +765,7 @@ var audioIteratorManager = ({
       nonce,
       playbackRate,
       startFromSecond: newTime,
+      unloopedStartFromSecond: unloopedNewTime,
       scheduleAudioNode,
       getTargetTime,
       logLevel,
@@ -771,9 +777,11 @@ var audioIteratorManager = ({
   return {
     startAudioIterator,
     getAudioBufferIterator: () => audioBufferIterator,
+    getCurrentAnchor: () => currentAnchor,
     destroyIterator: () => {
       audioBufferIterator?.destroy();
       audioBufferIterator = null;
+      currentAnchor = null;
       unblockCurrentDelayHandle();
     },
     seek,
@@ -1203,6 +1211,7 @@ var makePrewarmedVideoIteratorCache = (videoSink) => {
 };
 
 // src/video/video-preview-iterator.ts
+var MAXIMUM_AWAITED_PEEK_DISTANCE_SECONDS = 0.05;
 var createVideoIterator = async (timeToSeek, cache) => {
   let destroyed = false;
   const iterator = cache.makeIteratorOrUsePrewarmed(timeToSeek);
@@ -1217,17 +1226,61 @@ var createVideoIterator = async (timeToSeek, cache) => {
     }
     lastReturnedFrame = frame;
   };
-  const peek = async () => {
+  const setPeekedFrame = (frame) => {
+    peekedFrame = frame;
+    if (peekedFrame === null) {
+      iteratorEnded = true;
+    }
+    return peekedFrame;
+  };
+  const peekIfReady = () => {
     if (peekedFrame) {
-      return peekedFrame;
+      return { type: "ready", frame: peekedFrame };
+    }
+    if (iteratorEnded) {
+      return { type: "ready", frame: null };
     }
     const next = iterator.next();
     if (next.type === "ready") {
-      peekedFrame = next.frame;
-    } else {
-      peekedFrame = await next.wait();
+      return { type: "ready", frame: setPeekedFrame(next.frame) };
     }
-    return peekedFrame;
+    return {
+      type: "pending",
+      wait: next.wait
+    };
+  };
+  const peek = async () => {
+    const peeked = peekIfReady();
+    if (peeked.type === "ready") {
+      return peeked.frame;
+    }
+    return setPeekedFrame(await peeked.wait());
+  };
+  const getFrameEndTimestampFromPeek = (frame) => {
+    return frame ? roundTo4Digits(frame.timestamp) : Infinity;
+  };
+  const getFrameEndTimestamp = async () => {
+    return getFrameEndTimestampFromPeek(await peek());
+  };
+  const getFrameEndTimestampIfCloseEnough = async ({
+    timestamp,
+    frameTimestamp
+  }) => {
+    const peeked = peekIfReady();
+    if (peeked.type === "ready") {
+      return {
+        type: "ready",
+        timestamp: getFrameEndTimestampFromPeek(peeked.frame)
+      };
+    }
+    if (timestamp - frameTimestamp > MAXIMUM_AWAITED_PEEK_DISTANCE_SECONDS) {
+      return { type: "pending" };
+    }
+    const awaitedPeeked = setPeekedFrame(await peeked.wait());
+    return {
+      type: "ready",
+      timestamp: getFrameEndTimestampFromPeek(awaitedPeeked)
+    };
   };
   const getNextOrNullIfNotAvailable = () => {
     if (peekedFrame) {
@@ -1295,14 +1348,7 @@ var createVideoIterator = async (timeToSeek, cache) => {
           reason: `iterator is too far, most recently returned ${frameTimestamp}`
         };
       }
-      let lastFrameDuration = lastReturnedFrame.duration;
-      if (lastFrameDuration === 0) {
-        const peeked = await peek();
-        if (peeked) {
-          lastFrameDuration = peeked.timestamp - lastReturnedFrame.timestamp;
-        }
-      }
-      const frameEndTimestamp = roundTo4Digits(lastReturnedFrame.timestamp + lastFrameDuration);
+      const frameEndTimestamp = await getFrameEndTimestamp();
       if (frameTimestamp <= timestamp && frameEndTimestamp > timestamp) {
         return {
           type: "satisfied",
@@ -1345,8 +1391,17 @@ var createVideoIterator = async (timeToSeek, cache) => {
           };
         }
         const frameTimestamp = roundTo4Digits(frame.frame.timestamp);
-        const frameEndTimestamp = roundTo4Digits(frame.frame.timestamp + frame.frame.duration);
-        if (frameTimestamp <= timestamp && frameEndTimestamp > timestamp) {
+        const frameEndTimestamp = await getFrameEndTimestampIfCloseEnough({
+          frameTimestamp,
+          timestamp
+        });
+        if (frameEndTimestamp.type === "pending") {
+          return {
+            type: "not-satisfied",
+            reason: "iterator did not have next frame ready"
+          };
+        }
+        if (frameTimestamp <= timestamp && frameEndTimestamp.timestamp > timestamp) {
           return {
             type: "satisfied",
             frame: frame.frame
@@ -1770,6 +1825,7 @@ class MediaPlayer {
               nonce,
               playbackRate: this.playbackRate * this.globalPlaybackRate,
               startFromSecond: startTime,
+              unloopedStartFromSecond: startTimeUnresolved,
               scheduleAudioNode: this.scheduleAudioNode,
               getTargetTime: this.getTargetTime,
               logLevel: this.logLevel,
@@ -1801,10 +1857,10 @@ class MediaPlayer {
       __callDispose(__stack, _err, _hasErr);
     }
   }
-  seekToWithQueue = async (newTime) => {
+  seekToWithQueue = async (newTime, unloopedNewTime) => {
     const nonce = this.nonceManager.createAsyncOperation();
     await this.seekPromiseChain;
-    this.seekPromiseChain = this.seekToDoNotCallDirectly(newTime, nonce);
+    this.seekPromiseChain = this.seekToDoNotCallDirectly(newTime, unloopedNewTime, nonce);
     await this.seekPromiseChain;
   };
   async seekTo(time) {
@@ -1812,9 +1868,9 @@ class MediaPlayer {
     if (newTime === null) {
       throw new Error(`should have asserted that the time is not null`);
     }
-    await this.seekToWithQueue(newTime);
+    await this.seekToWithQueue(newTime, time);
   }
-  async seekToDoNotCallDirectly(newTime, nonce) {
+  async seekToDoNotCallDirectly(newTime, unloopedNewTime, nonce) {
     if (nonce.isStale()) {
       return;
     }
@@ -1826,8 +1882,10 @@ class MediaPlayer {
         }),
         this.audioIteratorManager?.seek({
           newTime,
+          unloopedNewTime,
           nonce,
           playbackRate: this.playbackRate * this.globalPlaybackRate,
+          localPlaybackRate: this.playbackRate,
           getTargetTime: this.getTargetTime,
           logLevel: this.logLevel,
           loop: this.loop,
@@ -1973,14 +2031,19 @@ class MediaPlayer {
     }
     const globalTime = (currentTime - this.sharedAudioContext.audioSyncAnchor.value) * this.globalPlaybackRate;
     const timeInSeconds = globalTime - this.sequenceOffset;
-    const localTime = this.getTrimmedTime(timeInSeconds);
+    const anchor = this.loop ? this.audioIteratorManager?.getCurrentAnchor() ?? null : null;
+    const localTime = anchor ? anchorToContinuousTime({
+      anchor,
+      unloopedTimeInSeconds: timeInSeconds,
+      playbackRate: this.playbackRate
+    }) : this.getTrimmedTime(timeInSeconds);
     if (localTime === null) {
       return null;
     }
     const targetTime = (mediaTimestamp - localTime) / (this.playbackRate * this.globalPlaybackRate);
     return targetTime;
   };
-  scheduleAudioNode = (node, mediaTimestamp, originalUnloopedMediaTimestamp) => {
+  scheduleAudioNode = (node, mediaTimestamp, originalUnloopedMediaTimestamp, sourceOffsetInSeconds, sourceDurationInSeconds) => {
     if (!this.sharedAudioContext) {
       throw new Error("Shared audio context not found");
     }
@@ -1993,18 +2056,17 @@ class MediaPlayer {
       };
     }
     const sequenceStartTime = this.getStartTime();
-    const loopSegmentMediaEndTimestamp = this.getLoopSegmentMediaEndTimestamp();
     const offset = getTrimStartForAudioNode({
       mediaTimestamp,
       targetTime,
       sequenceStartTime,
-      combinedPlaybackRate
+      combinedPlaybackRate,
+      sourceStartOffsetInSeconds: sourceOffsetInSeconds
     });
     const duration = getDurationOfNode({
-      bufferDuration: node.buffer?.duration ?? 0,
-      loopSegmentMediaEndTimestamp,
-      offset,
-      originalUnloopedMediaTimestamp
+      sourceDurationInSeconds,
+      sourceOffsetInSeconds,
+      offset
     });
     const scheduledTime = getScheduledTime({
       mediaTimestamp,
@@ -2015,6 +2077,7 @@ class MediaPlayer {
     return this.sharedAudioContext.scheduleAudioNode({
       node,
       mediaTimestamp,
+      sourceOffset: sourceOffsetInSeconds,
       scheduledTime,
       duration,
       offset,
@@ -2961,17 +3024,30 @@ var makeKeyframeBank = async ({
   let hasReachedEndOfVideo = false;
   let lastUsed = Date.now();
   let allocationSize = 0;
-  const getDurationOfFrame = (timestamp) => {
+  const getMeasuredDurationOfFrame = (timestamp) => {
     const index = frameTimestamps.indexOf(timestamp);
     if (index === -1) {
       throw new Error(`Frame ${timestamp} not found`);
     }
     const nextTimestamp = frameTimestamps[index + 1];
-    if (!nextTimestamp) {
+    if (nextTimestamp === undefined) {
       return null;
     }
     return nextTimestamp - timestamp;
   };
+  const getKnownDurationOfFrame = (timestamp) => {
+    const measuredDuration = getMeasuredDurationOfFrame(timestamp);
+    if (measuredDuration !== null) {
+      return measuredDuration;
+    }
+    if (!hasReachedEndOfVideo) {
+      return null;
+    }
+    return frames[timestamp].duration ?? 0;
+  };
+  const getEstimatedDurationOfFrame = (timestamp) => {
+    return getMeasuredDurationOfFrame(timestamp) ?? frames[timestamp].duration ?? 0;
+  };
   const deleteFrameAtTimestamp = (timestamp) => {
     allocationSize -= getAllocationSize(frames[timestamp]);
     frameTimestamps.splice(frameTimestamps.indexOf(timestamp), 1);
@@ -2993,7 +3069,10 @@ var makeKeyframeBank = async ({
       if (!frames[frameTimestamp]) {
         continue;
       }
-      const duration = getDurationOfFrame(frameTimestamp) ?? frames[frameTimestamp].duration;
+      const duration = getKnownDurationOfFrame(frameTimestamp);
+      if (duration === null) {
+        continue;
+      }
       if (frameTimestamp + duration < timestampInSeconds) {
         deleteFrameAtTimestamp(frameTimestamp);
         deletedTimestamps.push(frameTimestamp);
@@ -3005,14 +3084,20 @@ var makeKeyframeBank = async ({
   };
   const hasDecodedEnoughForTimestamp = (timestamp) => {
     const lastFrameTimestamp = frameTimestamps[frameTimestamps.length - 1];
-    if (!lastFrameTimestamp) {
+    if (lastFrameTimestamp === undefined) {
       return false;
     }
     const lastFrame = frames[lastFrameTimestamp];
     if (!lastFrame) {
       return true;
     }
-    const duration = getDurationOfFrame(lastFrameTimestamp) ?? lastFrame.duration;
+    if (roundTo4Digits(lastFrameTimestamp) >= roundTo4Digits(timestamp)) {
+      return true;
+    }
+    const duration = getKnownDurationOfFrame(lastFrameTimestamp);
+    if (duration === null) {
+      return false;
+    }
     return roundTo4Digits(lastFrameTimestamp + duration) > roundTo4Digits(timestamp);
   };
   const addFrame = (frame, logLevel) => {
@@ -3086,8 +3171,7 @@ var makeKeyframeBank = async ({
     }
     const firstTimestamp = frameTimestamps[0];
     const lastTimestamp = frameTimestamps[frameTimestamps.length - 1];
-    const lastFrame = frames[lastTimestamp];
-    const lastFrameDuration = getDurationOfFrame(lastTimestamp) ?? lastFrame.duration ?? 0;
+    const lastFrameDuration = getEstimatedDurationOfFrame(lastTimestamp);
     return {
       firstTimestamp,
       lastTimestamp: lastTimestamp + lastFrameDuration

package/dist/make-iterator-with-priming.d.ts

@@ -1,13 +1,21 @@
 import type { AudioBufferSink, WrappedAudioBuffer } from 'mediabunny';
-export type BufferWithMediaTimestamp = {
+export type AudioBufferSlice = {
     buffer: WrappedAudioBuffer;
-    timestamp: number;
+    timelineTimestamp: number;
+    sourceOffsetInSeconds: number;
+    sourceDurationInSeconds: number;
 };
-export declare const makeIteratorWithPriming: ({ audioSink, timeToSeek, maximumTimestamp, loop, playbackRate, sequenceDurationInSeconds, }: {
+export declare function makeIteratorWithPriming({ audioSink, timeToSeek, maximumTimestamp }: {
     audioSink: AudioBufferSink;
     timeToSeek: number;
     maximumTimestamp: number;
-    loop: boolean;
-    playbackRate: number;
-    sequenceDurationInSeconds: number;
-}) => AsyncGenerator<BufferWithMediaTimestamp, void, unknown>;
+}): AsyncGenerator<AudioBufferSlice, void, unknown>;
+type MakeLoopingIteratorOptions = {
+    audioSink: AudioBufferSink;
+    seekTimeInSeconds: number;
+    loopStartInSeconds: number;
+    segmentEndInSeconds: number;
+    maximumContinuousTimestamp: number;
+};
+export declare function makeLoopingIterator({ audioSink, seekTimeInSeconds, loopStartInSeconds, segmentEndInSeconds, maximumContinuousTimestamp }: MakeLoopingIteratorOptions): AsyncGenerator<AudioBufferSlice, void, unknown>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.486",
+	"version": "4.0.488",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -22,8 +22,8 @@
 		"make": "tsgo && bun --env-file=../.env.bundle bundle.ts"
 	},
 	"dependencies": {
-		"mediabunny": "1.50.3",
-		"remotion": "4.0.486",
+		"mediabunny": "1.50.8",
+		"remotion": "4.0.488",
 		"zod": "4.3.6"
 	},
 	"peerDependencies": {
@@ -31,8 +31,8 @@
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.486",
-		"@remotion/player": "4.0.486",
+		"@remotion/eslint-config-internal": "4.0.488",
+		"@remotion/player": "4.0.488",
 		"@vitest/browser-webdriverio": "4.0.9",
 		"eslint": "9.19.0",
 		"react": "19.2.3",