@remotion/media 4.0.364 → 4.0.366

package/dist/audio/audio-for-preview.js

@@ -1,11 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useContext, useEffect, useMemo, useRef, useState } from 'react';
-import { Internals, Audio as RemotionAudio, useBufferState, useCurrentFrame, } from 'remotion';
+import { Internals, Audio as RemotionAudio, useBufferState, useCurrentFrame, useVideoConfig, } from 'remotion';
+import { getTimeInSeconds } from '../get-time-in-seconds';
 import { MediaPlayer } from '../media-player';
 import { useLoopDisplay } from '../show-in-timeline';
 import { useMediaInTimeline } from '../use-media-in-timeline';
 const { useUnsafeVideoConfig, Timeline, SharedAudioContext, useMediaMutedState, useMediaVolumeState, useFrameForVolumeProp, evaluateVolume, warnAboutTooHighVolume, usePreload, SequenceContext, } = Internals;
-const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVolumeCurveBehavior, loop, trimAfter, trimBefore, name, showInTimeline, stack, disallowFallbackToHtml5Audio, toneFrequency, audioStreamIndex, fallbackHtml5AudioProps, }) => {
+const AudioForPreviewAssertedShowing = ({ src, playbackRate, logLevel, muted, volume, loopVolumeCurveBehavior, loop, trimAfter, trimBefore, name, showInTimeline, stack, disallowFallbackToHtml5Audio, toneFrequency, audioStreamIndex, fallbackHtml5AudioProps, }) => {
     const videoConfig = useUnsafeVideoConfig();
     const frame = useCurrentFrame();
     const mediaPlayerRef = useRef(null);
@@ -37,6 +38,8 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
     currentTimeRef.current = currentTime;
     const preloadedSrc = usePreload(src);
     const parentSequence = useContext(SequenceContext);
+    const isPremounting = Boolean(parentSequence?.premounting);
+    const isPostmounting = Boolean(parentSequence?.postmounting);
     const loopDisplay = useLoopDisplay({
         loop,
         mediaDurationInSeconds: videoConfig.durationInFrames,
@@ -59,6 +62,11 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
         trimAfter,
         trimBefore,
     });
+    const buffering = useContext(Internals.BufferingContextReact);
+    if (!buffering) {
+        throw new Error('useMediaPlayback must be used inside a <BufferingContext>');
+    }
+    const isPlayerBuffering = Internals.useIsPlayerBuffering(buffering);
     useEffect(() => {
         if (!sharedAudioContext)
             return;
@@ -78,6 +86,9 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
                 audioStreamIndex: audioStreamIndex ?? 0,
                 debugOverlay: false,
                 bufferState: buffer,
+                isPostmounting,
+                isPremounting,
+                globalPlaybackRate,
             });
             mediaPlayerRef.current = player;
             player
@@ -117,16 +128,16 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
                 }
                 if (result.type === 'success') {
                     setMediaPlayerReady(true);
-                    Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[NewAudioForPreview] MediaPlayer initialized successfully`);
+                    Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] MediaPlayer initialized successfully`);
                 }
             })
                 .catch((error) => {
-                Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[NewAudioForPreview] Failed to initialize MediaPlayer', error);
+                Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[AudioForPreview] Failed to initialize MediaPlayer', error);
                 setShouldFallbackToNativeAudio(true);
             });
         }
         catch (error) {
-            Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[NewAudioForPreview] MediaPlayer initialization failed', error);
+            Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[AudioForPreview] MediaPlayer initialization failed', error);
             setShouldFallbackToNativeAudio(true);
         }
         return () => {
@@ -135,7 +146,7 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
                 delayHandleRef.current = null;
             }
             if (mediaPlayerRef.current) {
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[NewAudioForPreview] Disposing MediaPlayer`);
+                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] Disposing MediaPlayer`);
                 mediaPlayerRef.current.dispose();
                 mediaPlayerRef.current = null;
             }
@@ -155,43 +166,30 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
         audioStreamIndex,
         disallowFallbackToHtml5Audio,
         buffer,
+        isPremounting,
+        isPostmounting,
+        globalPlaybackRate,
     ]);
     useEffect(() => {
         const audioPlayer = mediaPlayerRef.current;
         if (!audioPlayer)
             return;
-        if (playing) {
-            audioPlayer.play().catch((error) => {
-                Internals.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]);
     useEffect(() => {
         const audioPlayer = mediaPlayerRef.current;
         if (!audioPlayer || !mediaPlayerReady)
             return;
-        audioPlayer.seekTo(currentTime);
-        Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[NewAudioForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
-    }, [currentTime, logLevel, mediaPlayerReady]);
-    useEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady)
-            return;
-        audioPlayer.onBufferingChange((newBufferingState) => {
-            if (newBufferingState && !delayHandleRef.current) {
-                delayHandleRef.current = buffer.delayPlayback();
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, '[NewAudioForPreview] MediaPlayer buffering - blocking Remotion playback');
-            }
-            else if (!newBufferingState && delayHandleRef.current) {
-                delayHandleRef.current.unblock();
-                delayHandleRef.current = null;
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, '[NewAudioForPreview] MediaPlayer unbuffering - unblocking Remotion playback');
-            }
+        audioPlayer.seekTo(currentTime).catch(() => {
+            // Might be disposed
         });
-    }, [mediaPlayerReady, buffer, logLevel]);
+        Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
+    }, [currentTime, logLevel, mediaPlayerReady]);
     const effectiveMuted = muted || mediaMuted || userPreferredVolume <= 0;
     useEffect(() => {
         const audioPlayer = mediaPlayerRef.current;
@@ -206,14 +204,20 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
         }
         audioPlayer.setVolume(userPreferredVolume);
     }, [userPreferredVolume, mediaPlayerReady]);
-    const effectivePlaybackRate = useMemo(() => playbackRate * globalPlaybackRate, [playbackRate, globalPlaybackRate]);
     useEffect(() => {
         const audioPlayer = mediaPlayerRef.current;
         if (!audioPlayer || !mediaPlayerReady) {
             return;
         }
-        audioPlayer.setPlaybackRate(effectivePlaybackRate);
-    }, [effectivePlaybackRate, mediaPlayerReady]);
+        audioPlayer.setPlaybackRate(playbackRate);
+    }, [playbackRate, mediaPlayerReady]);
+    useEffect(() => {
+        const audioPlayer = mediaPlayerRef.current;
+        if (!audioPlayer || !mediaPlayerReady) {
+            return;
+        }
+        audioPlayer.setGlobalPlaybackRate(globalPlaybackRate);
+    }, [globalPlaybackRate, mediaPlayerReady]);
     useEffect(() => {
         const audioPlayer = mediaPlayerRef.current;
         if (!audioPlayer || !mediaPlayerReady) {
@@ -221,6 +225,41 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
         }
         audioPlayer.setFps(videoConfig.fps);
     }, [videoConfig.fps, mediaPlayerReady]);
+    useEffect(() => {
+        const mediaPlayer = mediaPlayerRef.current;
+        if (!mediaPlayer || !mediaPlayerReady) {
+            return;
+        }
+        mediaPlayer.setTrimBefore(trimBefore);
+    }, [trimBefore, mediaPlayerReady]);
+    useEffect(() => {
+        const mediaPlayer = mediaPlayerRef.current;
+        if (!mediaPlayer || !mediaPlayerReady) {
+            return;
+        }
+        mediaPlayer.setTrimAfter(trimAfter);
+    }, [trimAfter, mediaPlayerReady]);
+    useEffect(() => {
+        const mediaPlayer = mediaPlayerRef.current;
+        if (!mediaPlayer || !mediaPlayerReady) {
+            return;
+        }
+        mediaPlayer.setLoop(loop);
+    }, [loop, mediaPlayerReady]);
+    useEffect(() => {
+        const mediaPlayer = mediaPlayerRef.current;
+        if (!mediaPlayer || !mediaPlayerReady) {
+            return;
+        }
+        mediaPlayer.setIsPremounting(isPremounting);
+    }, [isPremounting, mediaPlayerReady]);
+    useEffect(() => {
+        const mediaPlayer = mediaPlayerRef.current;
+        if (!mediaPlayer || !mediaPlayerReady) {
+            return;
+        }
+        mediaPlayer.setIsPostmounting(isPostmounting);
+    }, [isPostmounting, mediaPlayerReady]);
     if (shouldFallbackToNativeAudio && !disallowFallbackToHtml5Audio) {
         return (_jsx(RemotionAudio, { src: src, muted: muted, volume: volume, startFrom: trimBefore, endAt: trimAfter, playbackRate: playbackRate, loopVolumeCurveBehavior: loopVolumeCurveBehavior, name: name, loop: loop, showInTimeline: showInTimeline, stack: stack ?? undefined, toneFrequency: toneFrequency, audioStreamIndex: audioStreamIndex, pauseWhenBuffering: fallbackHtml5AudioProps?.pauseWhenBuffering, ...fallbackHtml5AudioProps }));
     }
@@ -228,5 +267,32 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
 };
 export const AudioForPreview = ({ loop, src, logLevel, muted, name, volume, loopVolumeCurveBehavior, playbackRate, trimAfter, trimBefore, showInTimeline, stack, disallowFallbackToHtml5Audio, toneFrequency, audioStreamIndex, fallbackHtml5AudioProps, }) => {
     const preloadedSrc = usePreload(src);
-    return (_jsx(NewAudioForPreview, { audioStreamIndex: audioStreamIndex ?? 0, src: preloadedSrc, playbackRate: playbackRate ?? 1, logLevel: logLevel ?? window.remotion_logLevel, muted: muted ?? false, volume: volume ?? 1, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', loop: loop ?? false, trimAfter: trimAfter, trimBefore: trimBefore, name: name, showInTimeline: showInTimeline ?? true, stack: stack, disallowFallbackToHtml5Audio: disallowFallbackToHtml5Audio ?? false, toneFrequency: toneFrequency, fallbackHtml5AudioProps: fallbackHtml5AudioProps }));
+    const frame = useCurrentFrame();
+    const videoConfig = useVideoConfig();
+    const currentTime = frame / videoConfig.fps;
+    const showShow = useMemo(() => {
+        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 (_jsx(AudioForPreviewAssertedShowing, { audioStreamIndex: audioStreamIndex ?? 0, src: preloadedSrc, playbackRate: playbackRate ?? 1, logLevel: logLevel ?? window.remotion_logLevel, muted: muted ?? false, volume: volume ?? 1, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', loop: loop ?? false, trimAfter: trimAfter, trimBefore: trimBefore, name: name, showInTimeline: showInTimeline ?? true, stack: stack, disallowFallbackToHtml5Audio: disallowFallbackToHtml5Audio ?? false, toneFrequency: toneFrequency, fallbackHtml5AudioProps: fallbackHtml5AudioProps }));
 };

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

@@ -1,14 +1,37 @@
-import type { AudioBufferSink } from 'mediabunny';
+import type { AudioBufferSink, WrappedAudioBuffer } from 'mediabunny';
 export declare const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
+export type QueuedNode = {
+    node: AudioBufferSourceNode;
+    timestamp: number;
+    buffer: AudioBuffer;
+};
 export declare const makeAudioIterator: (audioSink: AudioBufferSink, startFromSecond: number) => {
-    cleanupAudioQueue: () => void;
     destroy: () => void;
-    isReadyToPlay: () => boolean;
-    setAudioIteratorStarted: (started: boolean) => void;
-    getNext: () => Promise<IteratorResult<import("mediabunny").WrappedAudioBuffer, void>>;
-    setAudioBufferHealth: (health: number) => void;
+    getNext: () => Promise<IteratorResult<WrappedAudioBuffer, void>>;
     isDestroyed: () => boolean;
-    addQueuedAudioNode: (node: AudioBufferSourceNode) => void;
+    addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer) => void;
     removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
+    getAndClearAudioChunksForAfterResuming: () => {
+        buffer: AudioBuffer;
+        timestamp: number;
+    }[];
+    getQueuedPeriod: (pendingBuffers: WrappedAudioBuffer[]) => {
+        from: number;
+        until: number;
+    } | null;
+    tryToSatisfySeek: (time: number, allowWait: boolean) => Promise<{
+        type: "not-satisfied";
+        reason: string;
+    } | {
+        type: "satisfied";
+        buffers: WrappedAudioBuffer[];
+    }>;
+    addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
+    moveQueuedChunksToPauseQueue: () => void;
+    getNumberOfChunksAfterResuming: () => number;
 };
 export type AudioIterator = ReturnType<typeof makeAudioIterator>;
+export declare const isAlreadyQueued: (time: number, queuedPeriod: {
+    from: number;
+    until: number;
+} | undefined | null) => boolean;

package/dist/audio/audio-preview-iterator.js

@@ -1,43 +1,196 @@
+import { roundTo4Digits } from '../helpers/round-to-4-digits';
 export const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
 export const 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.clear();
+        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;
+        }
+        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],
+                };
+            }
+            // fall through
+        }
+        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(() => undefined);
+            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,
     };
 };
+export const isAlreadyQueued = (time, queuedPeriod) => {
+    if (!queuedPeriod) {
+        return false;
+    }
+    return time >= queuedPeriod.from && time < queuedPeriod.until;
+};

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

@@ -0,0 +1,66 @@
+import type { InputAudioTrack, WrappedAudioBuffer } from 'mediabunny';
+import type { Nonce } from './nonce-manager';
+export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, }: {
+    audioTrack: InputAudioTrack;
+    delayPlaybackHandleIfNotPremounting: () => {
+        unblock: () => void;
+    };
+    sharedAudioContext: AudioContext;
+}) => {
+    startAudioIterator: ({ nonce, playbackRate, startFromSecond, getIsPlaying, scheduleAudioNode, }: {
+        startFromSecond: number;
+        nonce: Nonce;
+        playbackRate: number;
+        getIsPlaying: () => boolean;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+    }) => Promise<void>;
+    resumeScheduledAudioChunks: ({ playbackRate, scheduleAudioNode, }: {
+        playbackRate: number;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+    }) => void;
+    pausePlayback: () => void;
+    getAudioBufferIterator: () => {
+        destroy: () => void;
+        getNext: () => Promise<IteratorResult<WrappedAudioBuffer, void>>;
+        isDestroyed: () => boolean;
+        addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer) => void;
+        removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
+        getAndClearAudioChunksForAfterResuming: () => {
+            buffer: AudioBuffer;
+            timestamp: number;
+        }[];
+        getQueuedPeriod: (pendingBuffers: WrappedAudioBuffer[]) => {
+            from: number;
+            until: number;
+        } | null;
+        tryToSatisfySeek: (time: number, allowWait: boolean) => Promise<{
+            type: "not-satisfied";
+            reason: string;
+        } | {
+            type: "satisfied";
+            buffers: WrappedAudioBuffer[];
+        }>;
+        addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
+        moveQueuedChunksToPauseQueue: () => void;
+        getNumberOfChunksAfterResuming: () => number;
+    } | null;
+    destroy: () => void;
+    seek: ({ newTime, nonce, fps, playbackRate, getIsPlaying, scheduleAudioNode, }: {
+        newTime: number;
+        nonce: Nonce;
+        fps: number;
+        playbackRate: number;
+        getIsPlaying: () => boolean;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+    }) => Promise<void>;
+    getAudioIteratorsCreated: () => number;
+    setMuted: (newMuted: boolean) => void;
+    setVolume: (volume: number) => void;
+    scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, }: {
+        buffer: AudioBuffer;
+        mediaTimestamp: number;
+        playbackRate: number;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+    }) => void;
+};
+export type AudioIteratorManager = ReturnType<typeof audioIteratorManager>;