@remotion/media 4.0.365 → 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,
@@ -83,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
@@ -122,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 () => {
@@ -140,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;
             }
@@ -160,6 +166,9 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
         audioStreamIndex,
         disallowFallbackToHtml5Audio,
         buffer,
+        isPremounting,
+        isPostmounting,
+        globalPlaybackRate,
     ]);
     useEffect(() => {
         const audioPlayer = mediaPlayerRef.current;
@@ -176,8 +185,10 @@ const NewAudioForPreview = ({ src, playbackRate, logLevel, muted, volume, loopVo
         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`);
+        audioPlayer.seekTo(currentTime).catch(() => {
+            // Might be disposed
+        });
+        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(() => {
@@ -193,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) {
@@ -208,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 }));
     }
@@ -215,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

@@ -11,18 +11,24 @@ export declare const makeAudioIterator: (audioSink: AudioBufferSink, startFromSe
     isDestroyed: () => boolean;
     addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer) => void;
     removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
-    removeAndReturnAllQueuedAudioNodes: () => QueuedNode[];
-    getQueuedPeriod: () => {
+    getAndClearAudioChunksForAfterResuming: () => {
+        buffer: AudioBuffer;
+        timestamp: number;
+    }[];
+    getQueuedPeriod: (pendingBuffers: WrappedAudioBuffer[]) => {
         from: number;
         until: number;
     } | null;
-    tryToSatisfySeek: (time: number) => Promise<{
+    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: {

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

@@ -4,6 +4,7 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
     let destroyed = false;
     const iterator = audioSink.buffers(startFromSecond);
     const queuedAudioNodes = [];
+    const audioChunksForAfterResuming = [];
     const cleanupAudioQueue = () => {
         for (const node of queuedAudioNodes) {
             node.node.stop();
@@ -12,14 +13,16 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
     };
     let lastReturnedBuffer = null;
     let iteratorEnded = false;
-    const getNextOrNullIfNotAvailable = async () => {
+    const getNextOrNullIfNotAvailable = async (allowWait) => {
         const next = iterator.next();
-        const result = await Promise.race([
-            next,
-            new Promise((resolve) => {
-                Promise.resolve().then(() => resolve());
-            }),
-        ]);
+        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',
@@ -46,7 +49,7 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             buffer: result.value ?? null,
         };
     };
-    const tryToSatisfySeek = async (time) => {
+    const tryToSatisfySeek = async (time, allowWait) => {
         if (lastReturnedBuffer) {
             const bufferTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp);
             const bufferEndTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp + lastReturnedBuffer.duration);
@@ -65,20 +68,14 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             // fall through
         }
         if (iteratorEnded) {
-            if (lastReturnedBuffer) {
-                return {
-                    type: 'satisfied',
-                    buffers: [lastReturnedBuffer],
-                };
-            }
             return {
-                type: 'not-satisfied',
-                reason: 'iterator ended',
+                type: 'satisfied',
+                buffers: lastReturnedBuffer ? [lastReturnedBuffer] : [],
             };
         }
         const toBeReturned = [];
         while (true) {
-            const buffer = await getNextOrNullIfNotAvailable();
+            const buffer = await getNextOrNullIfNotAvailable(allowWait);
             if (buffer.type === 'need-to-wait-for-it') {
                 return {
                     type: 'not-satisfied',
@@ -88,15 +85,9 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             if (buffer.type === 'got-buffer-or-end') {
                 if (buffer.buffer === null) {
                     iteratorEnded = true;
-                    if (lastReturnedBuffer) {
-                        return {
-                            type: 'satisfied',
-                            buffers: [lastReturnedBuffer],
-                        };
-                    }
                     return {
-                        type: 'not-satisfied',
-                        reason: 'iterator ended and did not have buffer ready',
+                        type: 'satisfied',
+                        buffers: lastReturnedBuffer ? [lastReturnedBuffer] : [],
                     };
                 }
                 const bufferTimestamp = roundTo4Digits(buffer.buffer.timestamp);
@@ -114,14 +105,42 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             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 {
         destroy: () => {
             cleanupAudioQueue();
             destroyed = true;
             iterator.return().catch(() => undefined);
+            audioChunksForAfterResuming.length = 0;
         },
-        getNext: () => {
-            return iterator.next();
+        getNext: async () => {
+            const next = await iterator.next();
+            if (next.value) {
+                lastReturnedBuffer = next.value;
+            }
+            else {
+                iteratorEnded = true;
+            }
+            return next;
         },
         isDestroyed: () => {
             return destroyed;
@@ -135,29 +154,38 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
                 queuedAudioNodes.splice(index, 1);
             }
         },
-        removeAndReturnAllQueuedAudioNodes: () => {
-            const nodes = queuedAudioNodes.slice();
-            for (const node of nodes) {
-                node.node.stop();
-            }
-            queuedAudioNodes.length = 0;
-            return nodes;
+        getAndClearAudioChunksForAfterResuming: () => {
+            const chunks = audioChunksForAfterResuming.slice();
+            audioChunksForAfterResuming.length = 0;
+            return chunks;
         },
-        getQueuedPeriod: () => {
-            const lastNode = queuedAudioNodes[queuedAudioNodes.length - 1];
-            if (!lastNode) {
-                return null;
+        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);
             }
-            const firstNode = queuedAudioNodes[0];
-            if (!firstNode) {
+            if (!Number.isFinite(from) || !Number.isFinite(until)) {
                 return null;
             }
             return {
-                from: firstNode.timestamp,
-                until: lastNode.timestamp + lastNode.buffer.duration,
+                from,
+                until,
             };
         },
         tryToSatisfySeek,
+        addChunkForAfterResuming,
+        moveQueuedChunksToPauseQueue,
+        getNumberOfChunksAfterResuming,
     };
 };
 export const isAlreadyQueued = (time, queuedPeriod) => {

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>;

package/dist/audio-iterator-manager.js

@@ -0,0 +1,181 @@
+import { AudioBufferSink } from 'mediabunny';
+import { isAlreadyQueued, makeAudioIterator, } from './audio/audio-preview-iterator';
+export const 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 = () => {
+            // Some leniancy is needed as we find that sometimes onended is fired a bit too early
+            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;
+        // Schedule up to 3 buffers ahead of the current time
+        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) {
+                // media ended
+                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 +
+            // start of next frame
+            (1 / fps) * playbackRate +
+            // need the full duration of the next frame to be queued
+            (1 / fps) * playbackRate;
+        const nextIsAlreadyQueued = isAlreadyQueued(nextTime, audioBufferIterator.getQueuedPeriod(toBeScheduled));
+        if (!nextIsAlreadyQueued) {
+            // here we allow waiting for the next buffer to be loaded
+            // it's better than to create a new iterator
+            // because we already know we are in the right spot
+            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,
+    };
+};

package/dist/calculate-playbacktime.d.ts

@@ -0,0 +1,5 @@
+export declare const calculatePlaybackTime: ({ audioSyncAnchor, currentTime, playbackRate, }: {
+    audioSyncAnchor: number;
+    currentTime: number;
+    playbackRate: number;
+}) => number;

package/dist/calculate-playbacktime.js

@@ -0,0 +1,4 @@
+export const calculatePlaybackTime = ({ audioSyncAnchor, currentTime, playbackRate, }) => {
+    const timeSinceAnchor = currentTime - audioSyncAnchor;
+    return timeSinceAnchor * playbackRate;
+};