@remotion/media 4.0.451 → 4.0.453

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

@@ -25,7 +25,6 @@ type InnerAudioProps = {
     readonly toneFrequency?: number;
     readonly audioStreamIndex?: number;
     readonly fallbackHtml5AudioProps?: FallbackHtml5AudioProps;
-    readonly debugAudioScheduling?: boolean;
     readonly onError?: MediaOnError;
     readonly credentials?: RequestCredentials;
 };

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

@@ -1,6 +1,6 @@
-import type { WrappedAudioBuffer } from 'mediabunny';
-import type { SharedAudioContextForMediaPlayer } from '../shared-audio-context-for-media-player';
+import type { AudioBufferSink } from 'mediabunny';
 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;
@@ -13,57 +13,31 @@ export type QueuedPeriod = {
     from: number;
     until: number;
 };
-export declare const makeAudioIterator: ({ startFromSecond, maximumTimestamp, cache, debugAudioScheduling, }: {
+export declare const makeAudioIterator: ({ startFromSecond, maximumTimestamp, audioSink, loop, playbackRate, sequenceDurationInSeconds, unscheduleAudioNode, }: {
     startFromSecond: number;
     maximumTimestamp: number;
-    cache: {
-        prewarmIteratorForLooping: ({ timeToSeek, maximumTimestamp, }: {
-            timeToSeek: number;
-            maximumTimestamp: number;
-        }) => void;
-        makeIteratorOrUsePrewarmed: (timeToSeek: number, maximumTimestamp: number) => AsyncGenerator<WrappedAudioBuffer, void, unknown>;
-        destroy: () => void;
-    };
-    debugAudioScheduling: boolean;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    audioSink: AudioBufferSink;
+    loop: boolean;
+    playbackRate: number;
+    sequenceDurationInSeconds: number;
+    unscheduleAudioNode: (node: AudioBufferSourceNode) => void;
 }) => {
-    destroy: (audioContext: SharedAudioContextForMediaPlayer) => void;
-    getNext: () => Promise<IteratorResult<WrappedAudioBuffer, void>>;
+    destroy: () => void;
+    getNextFn: () => Promise<IteratorResult<import("../make-iterator-with-priming").BufferWithMediaTimestamp, void>>;
     isDestroyed: () => boolean;
-    addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, playbackRate, scheduledAtAnchor, }: {
+    addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, scheduledAtAnchor, }: {
         node: AudioBufferSourceNode;
         timestamp: number;
         buffer: AudioBuffer;
         scheduledTime: number;
-        playbackRate: number;
         scheduledAtAnchor: number;
     }) => void;
-    removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
-    getAndClearAudioChunksForAfterResuming: () => {
-        buffer: AudioBuffer;
-        timestamp: number;
-    }[];
+    guessNextTimestamp: () => number;
     getQueuedPeriod: () => {
         from: number;
         until: number;
     } | null;
-    tryToSatisfySeek: (time: number, onBufferScheduled: (buffer: WrappedAudioBuffer) => void) => Promise<{
-        type: "not-satisfied";
-        reason: string;
-    } | {
-        type: "ended";
-    } | {
-        type: "satisfied";
-    }>;
-    bufferAsFarAsPossible: (onBufferScheduled: (buffer: WrappedAudioBuffer) => void, maxTimestamp: number) => Promise<{
-        type: "ended";
-    } | {
-        type: "waiting";
-    } | {
-        type: "max-reached";
-    }>;
-    addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
-    moveQueuedChunksToPauseQueue: () => void;
-    getNumberOfChunksAfterResuming: () => number;
 };
 export type AudioIterator = ReturnType<typeof makeAudioIterator>;
 export declare const isAlreadyQueued: (time: number, queuedPeriod: {

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

@@ -4,11 +4,11 @@ export declare const getScheduledTime: ({ mediaTimestamp, targetTime, currentTim
     currentTime: number;
     sequenceStartTime: number;
 }) => number;
-export declare const getDurationOfNode: ({ mediaTimestamp, bufferDuration, sequenceEndTime, offset, }: {
-    mediaTimestamp: number;
+export declare const getDurationOfNode: ({ bufferDuration, loopSegmentMediaEndTimestamp, offset, originalUnloopedMediaTimestamp, }: {
     bufferDuration: number;
-    sequenceEndTime: number;
+    loopSegmentMediaEndTimestamp: number;
     offset: number;
+    originalUnloopedMediaTimestamp: number;
 }) => number;
 export declare const getOffset: ({ mediaTimestamp, targetTime, sequenceStartTime, }: {
     mediaTimestamp: number;

package/dist/audio/props.d.ts

@@ -39,7 +39,6 @@ export type AudioProps = {
     toneFrequency?: number;
     delayRenderRetries?: number;
     delayRenderTimeoutInMilliseconds?: number;
-    debugAudioScheduling?: boolean;
     onError?: MediaOnError;
     credentials?: RequestCredentials;
 };

package/dist/audio/sort-by-priority.d.ts

@@ -1,6 +1,7 @@
 export declare class StaleWaiterError extends Error {
     constructor();
 }
+export declare const processNext: () => void;
 export declare const waitForTurn: <T>({ getPriority, fn, onDone, onError, }: {
     getPriority: () => number | null;
     fn: () => Promise<T>;

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

@@ -1,92 +1,86 @@
-import type { InputAudioTrack, WrappedAudioBuffer } from 'mediabunny';
+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 { Nonce } from './nonce-manager';
 import type { SharedAudioContextForMediaPlayer } from './shared-audio-context-for-media-player';
-type ScheduleAudioNode = (node: AudioBufferSourceNode, mediaTimestamp: number) => ScheduleAudioNodeResult;
-export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getIsLooping, getEndTime, getStartTime, initialMuted, drawDebugOverlay, }: {
+type ScheduleAudioNode = (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, currentTime: number) => ScheduleAudioNodeResult;
+export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getSequenceEndTimestamp, getSequenceDurationInSeconds, getMediaEndTimestamp, getStartTime, initialMuted, drawDebugOverlay, initialPlaybackRate, initialTrimBefore, initialTrimAfter, initialSequenceOffset, initialSequenceDurationInFrames, initialLoop, initialFps, }: {
     audioTrack: InputAudioTrack;
     delayPlaybackHandleIfNotPremounting: () => DelayPlaybackIfNotPremounting;
     sharedAudioContext: SharedAudioContextForMediaPlayer;
-    getIsLooping: () => boolean;
-    getEndTime: () => number;
+    getSequenceEndTimestamp: () => number;
+    getSequenceDurationInSeconds: () => number;
+    getMediaEndTimestamp: () => number;
     getStartTime: () => number;
     initialMuted: boolean;
     drawDebugOverlay: () => void;
+    initialPlaybackRate: number;
+    initialTrimBefore: number | undefined;
+    initialTrimAfter: number | undefined;
+    initialSequenceOffset: number;
+    initialSequenceDurationInFrames: number;
+    initialLoop: boolean;
+    initialFps: number;
 }) => {
-    startAudioIterator: ({ nonce, playbackRate, startFromSecond, getIsPlaying, scheduleAudioNode, debugAudioScheduling, }: {
+    startAudioIterator: ({ nonce, playbackRate, startFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
         startFromSecond: number;
         nonce: Nonce;
         playbackRate: number;
-        getIsPlaying: () => boolean;
         scheduleAudioNode: ScheduleAudioNode;
-        debugAudioScheduling: boolean;
-    }) => Promise<void>;
-    resumeScheduledAudioChunks: ({ playbackRate, scheduleAudioNode, debugAudioScheduling, }: {
-        playbackRate: number;
-        scheduleAudioNode: ScheduleAudioNode;
-        debugAudioScheduling: boolean;
+        getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+        loop: boolean;
+        unscheduleAudioNode: (node: AudioBufferSourceNode) => void;
+        getAudioContextCurrentTimeMockedInTest: () => number;
     }) => void;
-    pausePlayback: () => void;
     getAudioBufferIterator: () => {
-        destroy: (audioContext: SharedAudioContextForMediaPlayer) => void;
-        getNext: () => Promise<IteratorResult<WrappedAudioBuffer, void>>;
+        destroy: () => void;
+        getNextFn: () => Promise<IteratorResult<BufferWithMediaTimestamp, void>>;
         isDestroyed: () => boolean;
-        addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, playbackRate, scheduledAtAnchor, }: {
+        addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, scheduledAtAnchor, }: {
             node: AudioBufferSourceNode;
             timestamp: number;
             buffer: AudioBuffer;
             scheduledTime: number;
-            playbackRate: number;
             scheduledAtAnchor: number;
         }) => void;
-        removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
-        getAndClearAudioChunksForAfterResuming: () => {
-            buffer: AudioBuffer;
-            timestamp: number;
-        }[];
+        guessNextTimestamp: () => number;
         getQueuedPeriod: () => {
             from: number;
             until: number;
         } | null;
-        tryToSatisfySeek: (time: number, onBufferScheduled: (buffer: WrappedAudioBuffer) => void) => Promise<{
-            type: "not-satisfied";
-            reason: string;
-        } | {
-            type: "ended";
-        } | {
-            type: "satisfied";
-        }>;
-        bufferAsFarAsPossible: (onBufferScheduled: (buffer: WrappedAudioBuffer) => void, maxTimestamp: number) => Promise<{
-            type: "ended";
-        } | {
-            type: "waiting";
-        } | {
-            type: "max-reached";
-        }>;
-        addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
-        moveQueuedChunksToPauseQueue: () => void;
-        getNumberOfChunksAfterResuming: () => number;
     } | null;
     destroyIterator: () => void;
-    seek: ({ newTime, nonce, playbackRate, getIsPlaying, scheduleAudioNode, debugAudioScheduling, }: {
+    seek: ({ newTime, nonce, playbackRate, scheduleAudioNode, getTargetTime, logLevel, loop, trimBefore, trimAfter, sequenceOffset, sequenceDurationInFrames, fps, getAudioContextCurrentTimeMockedInTest, }: {
         newTime: number;
         nonce: Nonce;
         playbackRate: number;
-        getIsPlaying: () => boolean;
         scheduleAudioNode: ScheduleAudioNode;
-        debugAudioScheduling: boolean;
-    }) => Promise<void>;
+        getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+        loop: boolean;
+        trimBefore: number | undefined;
+        trimAfter: number | undefined;
+        sequenceOffset: number;
+        sequenceDurationInFrames: number;
+        fps: number;
+        getAudioContextCurrentTimeMockedInTest: () => number;
+    }) => void;
     getAudioIteratorsCreated: () => number;
+    getTotalAudioScheduledInSeconds: () => number;
     setMuted: (newMuted: boolean) => void;
     setVolume: (volume: number) => void;
-    scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, debugAudioScheduling, }: {
+    scheduleAudioChunk: ({ buffer, mediaTimestamp, originalUnloopedMediaTimestamp, playbackRate, scheduleAudioNode, logLevel, currentTime, }: {
         buffer: AudioBuffer;
         mediaTimestamp: number;
         playbackRate: number;
         scheduleAudioNode: ScheduleAudioNode;
-        debugAudioScheduling: boolean;
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+        originalUnloopedMediaTimestamp: number;
+        currentTime: number;
     }) => void;
+    waitForNScheduledNodes: (n: number) => Promise<void>;
 };
 export type AudioIteratorManager = ReturnType<typeof audioIteratorManager>;
 export {};

package/dist/canvas-ahead-of-time.d.ts

@@ -0,0 +1,13 @@
+import type { CanvasSink, WrappedCanvas } from 'mediabunny';
+export type CanvasAheadOfTimeNext = {
+    type: 'ready';
+    frame: WrappedCanvas | null;
+} | {
+    type: 'pending';
+    wait: () => Promise<WrappedCanvas | null>;
+};
+export declare const canvasesAheadOfTime: (videoSink: CanvasSink, startTimestamp?: number | undefined) => {
+    next: () => CanvasAheadOfTimeNext;
+    closeIterator: () => Promise<void>;
+};
+export type CanvasAheadOfTimeIterator = ReturnType<typeof canvasesAheadOfTime>;

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

@@ -7,79 +7,64 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
     } | null;
     playing: boolean;
     audioIteratorManager: {
-        startAudioIterator: ({ nonce, playbackRate, startFromSecond, getIsPlaying, scheduleAudioNode, debugAudioScheduling, }: {
+        startAudioIterator: ({ nonce, playbackRate, startFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
             startFromSecond: number;
             nonce: import("../nonce-manager").Nonce;
             playbackRate: number;
-            getIsPlaying: () => boolean;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => import("remotion").ScheduleAudioNodeResult;
-            debugAudioScheduling: boolean;
-        }) => Promise<void>;
-        resumeScheduledAudioChunks: ({ playbackRate, scheduleAudioNode, debugAudioScheduling, }: {
-            playbackRate: number;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => import("remotion").ScheduleAudioNodeResult;
-            debugAudioScheduling: boolean;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, currentTime: number) => import("remotion").ScheduleAudioNodeResult;
+            getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
+            logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+            loop: boolean;
+            unscheduleAudioNode: (node: AudioBufferSourceNode) => void;
+            getAudioContextCurrentTimeMockedInTest: () => number;
         }) => void;
-        pausePlayback: () => void;
         getAudioBufferIterator: () => {
-            destroy: (audioContext: import("../shared-audio-context-for-media-player").SharedAudioContextForMediaPlayer) => void;
-            getNext: () => Promise<IteratorResult<import("mediabunny").WrappedAudioBuffer, void>>;
+            destroy: () => void;
+            getNextFn: () => Promise<IteratorResult<import("../make-iterator-with-priming").BufferWithMediaTimestamp, void>>;
             isDestroyed: () => boolean;
-            addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, playbackRate, scheduledAtAnchor, }: {
+            addQueuedAudioNode: ({ node, timestamp, buffer, scheduledTime, scheduledAtAnchor, }: {
                 node: AudioBufferSourceNode;
                 timestamp: number;
                 buffer: AudioBuffer;
                 scheduledTime: number;
-                playbackRate: number;
                 scheduledAtAnchor: number;
             }) => void;
-            removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
-            getAndClearAudioChunksForAfterResuming: () => {
-                buffer: AudioBuffer;
-                timestamp: number;
-            }[];
+            guessNextTimestamp: () => number;
             getQueuedPeriod: () => {
                 from: number;
                 until: number;
             } | null;
-            tryToSatisfySeek: (time: number, onBufferScheduled: (buffer: import("mediabunny").WrappedAudioBuffer) => void) => Promise<{
-                type: "not-satisfied";
-                reason: string;
-            } | {
-                type: "ended";
-            } | {
-                type: "satisfied";
-            }>;
-            bufferAsFarAsPossible: (onBufferScheduled: (buffer: import("mediabunny").WrappedAudioBuffer) => void, maxTimestamp: number) => Promise<{
-                type: "ended";
-            } | {
-                type: "waiting";
-            } | {
-                type: "max-reached";
-            }>;
-            addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
-            moveQueuedChunksToPauseQueue: () => void;
-            getNumberOfChunksAfterResuming: () => number;
         } | null;
         destroyIterator: () => void;
-        seek: ({ newTime, nonce, playbackRate, getIsPlaying, scheduleAudioNode, debugAudioScheduling, }: {
+        seek: ({ newTime, nonce, playbackRate, scheduleAudioNode, getTargetTime, logLevel, loop, trimBefore, trimAfter, sequenceOffset, sequenceDurationInFrames, fps, getAudioContextCurrentTimeMockedInTest, }: {
             newTime: number;
             nonce: import("../nonce-manager").Nonce;
             playbackRate: number;
-            getIsPlaying: () => boolean;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => import("remotion").ScheduleAudioNodeResult;
-            debugAudioScheduling: boolean;
-        }) => Promise<void>;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, currentTime: number) => import("remotion").ScheduleAudioNodeResult;
+            getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
+            logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+            loop: boolean;
+            trimBefore: number | undefined;
+            trimAfter: number | undefined;
+            sequenceOffset: number;
+            sequenceDurationInFrames: number;
+            fps: number;
+            getAudioContextCurrentTimeMockedInTest: () => number;
+        }) => void;
         getAudioIteratorsCreated: () => number;
+        getTotalAudioScheduledInSeconds: () => number;
         setMuted: (newMuted: boolean) => void;
         setVolume: (volume: number) => void;
-        scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, debugAudioScheduling, }: {
+        scheduleAudioChunk: ({ buffer, mediaTimestamp, originalUnloopedMediaTimestamp, playbackRate, scheduleAudioNode, logLevel, currentTime, }: {
             buffer: AudioBuffer;
             mediaTimestamp: number;
             playbackRate: number;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => import("remotion").ScheduleAudioNodeResult;
-            debugAudioScheduling: boolean;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, currentTime: number) => import("remotion").ScheduleAudioNodeResult;
+            logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+            originalUnloopedMediaTimestamp: number;
+            currentTime: number;
         }) => void;
+        waitForNScheduledNodes: (n: number) => Promise<void>;
     } | null;
     videoIteratorManager: {
         startVideoIterator: (timeToSeek: number, nonce: import("../nonce-manager").Nonce) => Promise<void>;
@@ -93,13 +78,13 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
             destroy: () => void;
             initialFrame: import("mediabunny").WrappedCanvas | null;
             isDestroyed: () => boolean;
-            tryToSatisfySeek: (time: number) => Promise<{
+            tryToSatisfySeek: (time: number) => {
                 type: "not-satisfied";
                 reason: string;
             } | {
                 type: "satisfied";
                 frame: import("mediabunny").WrappedCanvas;
-            }>;
+            };
         } | null;
         drawFrame: (frame: import("mediabunny").WrappedCanvas) => void;
         getFramesRendered: () => number;