@remotion/media 4.0.370 → 4.0.371

package/dist/audio/allow-wait.d.ts

@@ -0,0 +1,6 @@
+import type { WrappedAudioBuffer } from 'mediabunny';
+export type AllowWait = {
+    type: 'allow-wait';
+    waitCallback: () => () => void;
+};
+export declare const allowWaitRoutine: (next: Promise<IteratorResult<WrappedAudioBuffer, void>>, waitFn: AllowWait) => Promise<IteratorResult<WrappedAudioBuffer, void>>;

package/dist/audio/allow-wait.js

@@ -0,0 +1,15 @@
+export const allowWaitRoutine = async (next, waitFn) => {
+    const result = await Promise.race([
+        next,
+        new Promise((resolve) => {
+            Promise.resolve().then(() => resolve());
+        }),
+    ]);
+    if (!result) {
+        const unblock = waitFn.waitCallback();
+        const newRes = await next;
+        unblock();
+        return newRes;
+    }
+    return result;
+};

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

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
 import { Internals, Audio as RemotionAudio, useBufferState, useCurrentFrame, useVideoConfig, } from 'remotion';
 import { getTimeInSeconds } from '../get-time-in-seconds';
 import { MediaPlayer } from '../media-player';
@@ -181,7 +181,7 @@ const AudioForPreviewAssertedShowing = ({ src, playbackRate, logLevel, muted, vo
             audioPlayer.pause();
         }
     }, [isPlayerBuffering, logLevel, playing]);
-    useEffect(() => {
+    useLayoutEffect(() => {
         const audioPlayer = mediaPlayerRef.current;
         if (!audioPlayer || !mediaPlayerReady)
             return;

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

@@ -1,4 +1,5 @@
 import type { AudioBufferSink, WrappedAudioBuffer } from 'mediabunny';
+import { type AllowWait } from './allow-wait';
 export declare const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
 export type QueuedNode = {
     node: AudioBufferSourceNode;
@@ -15,16 +16,15 @@ export declare const makeAudioIterator: (audioSink: AudioBufferSink, startFromSe
         buffer: AudioBuffer;
         timestamp: number;
     }[];
-    getQueuedPeriod: (pendingBuffers: WrappedAudioBuffer[]) => {
+    getQueuedPeriod: () => {
         from: number;
         until: number;
     } | null;
-    tryToSatisfySeek: (time: number, allowWait: boolean) => Promise<{
+    tryToSatisfySeek: (time: number, allowWait: AllowWait | null, onBufferScheduled: (buffer: WrappedAudioBuffer) => void) => Promise<{
         type: "not-satisfied";
         reason: string;
     } | {
         type: "satisfied";
-        buffers: WrappedAudioBuffer[];
     }>;
     addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
     moveQueuedChunksToPauseQueue: () => void;

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

@@ -1,4 +1,5 @@
 import { roundTo4Digits } from '../helpers/round-to-4-digits';
+import { allowWaitRoutine } from './allow-wait';
 export const HEALTHY_BUFFER_THRESHOLD_SECONDS = 1;
 export const makeAudioIterator = (audioSink, startFromSecond) => {
     let destroyed = false;
@@ -16,7 +17,7 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
     const getNextOrNullIfNotAvailable = async (allowWait) => {
         const next = iterator.next();
         const result = allowWait
-            ? await next
+            ? await allowWaitRoutine(next, allowWait)
             : await Promise.race([
                 next,
                 new Promise((resolve) => {
@@ -49,7 +50,7 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             buffer: result.value ?? null,
         };
     };
-    const tryToSatisfySeek = async (time, allowWait) => {
+    const tryToSatisfySeek = async (time, allowWait, onBufferScheduled) => {
         if (lastReturnedBuffer) {
             const bufferTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp);
             const bufferEndTimestamp = roundTo4Digits(lastReturnedBuffer.timestamp + lastReturnedBuffer.duration);
@@ -60,20 +61,21 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
                 };
             }
             if (roundTo4Digits(time) <= bufferEndTimestamp) {
+                onBufferScheduled(lastReturnedBuffer);
                 return {
                     type: 'satisfied',
-                    buffers: [lastReturnedBuffer],
                 };
             }
             // fall through
         }
         if (iteratorEnded) {
+            if (lastReturnedBuffer) {
+                onBufferScheduled(lastReturnedBuffer);
+            }
             return {
                 type: 'satisfied',
-                buffers: lastReturnedBuffer ? [lastReturnedBuffer] : [],
             };
         }
-        const toBeReturned = [];
         while (true) {
             const buffer = await getNextOrNullIfNotAvailable(allowWait);
             if (buffer.type === 'need-to-wait-for-it') {
@@ -85,21 +87,23 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             if (buffer.type === 'got-buffer-or-end') {
                 if (buffer.buffer === null) {
                     iteratorEnded = true;
+                    if (lastReturnedBuffer) {
+                        onBufferScheduled(lastReturnedBuffer);
+                    }
                     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) {
+                    onBufferScheduled(buffer.buffer);
                     return {
                         type: 'satisfied',
-                        buffers: [...toBeReturned, buffer.buffer],
                     };
                 }
-                toBeReturned.push(buffer.buffer);
+                onBufferScheduled(buffer.buffer);
                 continue;
             }
             throw new Error('Unreachable');
@@ -159,13 +163,9 @@ export const makeAudioIterator = (audioSink, startFromSecond) => {
             audioChunksForAfterResuming.length = 0;
             return chunks;
         },
-        getQueuedPeriod: (pendingBuffers) => {
+        getQueuedPeriod: () => {
             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);

package/dist/audio-extraction/extract-audio.js

@@ -84,6 +84,8 @@ const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds,
             trimStartInSeconds,
             trimEndInSeconds,
             playbackRate,
+            audioDataTimestamp: sample.timestamp,
+            isLast: isLastSample,
         });
         audioDataRaw.close();
         if (audioData.numberOfFrames === 0) {

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

@@ -1,4 +1,5 @@
 import type { InputAudioTrack, WrappedAudioBuffer } from 'mediabunny';
+import type { useBufferState } from 'remotion';
 import type { Nonce } from './nonce-manager';
 export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, }: {
     audioTrack: InputAudioTrack;
@@ -29,28 +30,28 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
             buffer: AudioBuffer;
             timestamp: number;
         }[];
-        getQueuedPeriod: (pendingBuffers: WrappedAudioBuffer[]) => {
+        getQueuedPeriod: () => {
             from: number;
             until: number;
         } | null;
-        tryToSatisfySeek: (time: number, allowWait: boolean) => Promise<{
+        tryToSatisfySeek: (time: number, allowWait: import("./audio/allow-wait").AllowWait | null, onBufferScheduled: (buffer: WrappedAudioBuffer) => void) => 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, }: {
+    seek: ({ newTime, nonce, fps, playbackRate, getIsPlaying, scheduleAudioNode, bufferState, }: {
         newTime: number;
         nonce: Nonce;
         fps: number;
         playbackRate: number;
         getIsPlaying: () => boolean;
+        bufferState: ReturnType<typeof useBufferState>;
         scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
     }) => Promise<void>;
     getAudioIteratorsCreated: () => number;

package/dist/audio-iterator-manager.js

@@ -79,7 +79,7 @@ export const audioIteratorManager = ({ audioTrack, delayPlaybackHandleIfNotPremo
         }
         audioBufferIterator.moveQueuedChunksToPauseQueue();
     };
-    const seek = async ({ newTime, nonce, fps, playbackRate, getIsPlaying, scheduleAudioNode, }) => {
+    const seek = async ({ newTime, nonce, fps, playbackRate, getIsPlaying, scheduleAudioNode, bufferState, }) => {
         if (!audioBufferIterator) {
             await startAudioIterator({
                 nonce,
@@ -90,10 +90,18 @@ export const audioIteratorManager = ({ audioTrack, delayPlaybackHandleIfNotPremo
             });
             return;
         }
-        const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, audioBufferIterator.getQueuedPeriod([]));
-        const toBeScheduled = [];
+        const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, audioBufferIterator.getQueuedPeriod());
         if (!currentTimeIsAlreadyQueued) {
-            const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(newTime, false);
+            const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(newTime, null, (buffer) => {
+                if (!nonce.isStale()) {
+                    onAudioChunk({
+                        getIsPlaying,
+                        buffer,
+                        playbackRate,
+                        scheduleAudioNode,
+                    });
+                }
+            });
             if (nonce.isStale()) {
                 return;
             }
@@ -107,19 +115,33 @@ export const audioIteratorManager = ({ audioTrack, delayPlaybackHandleIfNotPremo
                 });
                 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));
+            // 3 frames ahead to get enough of a buffer
+            (1 / fps) * Math.max(1, playbackRate) * 3;
+        const nextIsAlreadyQueued = isAlreadyQueued(nextTime, audioBufferIterator.getQueuedPeriod());
         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);
+            const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(nextTime, {
+                type: 'allow-wait',
+                waitCallback: () => {
+                    const handle = bufferState.delayPlayback();
+                    return () => {
+                        handle.unblock();
+                    };
+                },
+            }, (buffer) => {
+                if (!nonce.isStale()) {
+                    onAudioChunk({
+                        getIsPlaying,
+                        buffer,
+                        playbackRate,
+                        scheduleAudioNode,
+                    });
+                }
+            });
             if (nonce.isStale()) {
                 return;
             }
@@ -131,17 +153,7 @@ export const audioIteratorManager = ({ audioTrack, delayPlaybackHandleIfNotPremo
                     getIsPlaying,
                     scheduleAudioNode,
                 });
-                return;
             }
-            toBeScheduled.push(...audioSatisfyResult.buffers);
-        }
-        for (const buffer of toBeScheduled) {
-            onAudioChunk({
-                getIsPlaying,
-                buffer,
-                playbackRate,
-                scheduleAudioNode,
-            });
         }
     };
     const resumeScheduledAudioChunks = ({ playbackRate, scheduleAudioNode, }) => {

package/dist/convert-audiodata/combine-audiodata.d.ts

@@ -1,2 +1,2 @@
-import type { PcmS16AudioData } from './convert-audiodata';
+import { type PcmS16AudioData } from './convert-audiodata';
 export declare const combineAudioDataAndClosePrevious: (audioDataArray: PcmS16AudioData[]) => PcmS16AudioData;

package/dist/convert-audiodata/combine-audiodata.js

@@ -1,9 +1,12 @@
+import { fixFloatingPoint } from './convert-audiodata';
 import { TARGET_NUMBER_OF_CHANNELS } from './resample-audiodata';
 export const combineAudioDataAndClosePrevious = (audioDataArray) => {
     let numberOfFrames = 0;
+    let durationInMicroSeconds = 0;
     const { timestamp } = audioDataArray[0];
     for (const audioData of audioDataArray) {
         numberOfFrames += audioData.numberOfFrames;
+        durationInMicroSeconds += audioData.durationInMicroSeconds;
     }
     const arr = new Int16Array(numberOfFrames * TARGET_NUMBER_OF_CHANNELS);
     let offset = 0;
@@ -14,6 +17,7 @@ export const combineAudioDataAndClosePrevious = (audioDataArray) => {
     return {
         data: arr,
         numberOfFrames,
-        timestamp,
+        timestamp: fixFloatingPoint(timestamp),
+        durationInMicroSeconds: fixFloatingPoint(durationInMicroSeconds),
     };
 };

package/dist/convert-audiodata/convert-audiodata.d.ts

@@ -3,10 +3,14 @@ export type ConvertAudioDataOptions = {
     trimStartInSeconds: number;
     trimEndInSeconds: number;
     playbackRate: number;
+    audioDataTimestamp: number;
+    isLast: boolean;
 };
 export type PcmS16AudioData = {
     data: Int16Array;
     numberOfFrames: number;
     timestamp: number;
+    durationInMicroSeconds: number;
 };
-export declare const convertAudioData: ({ audioData, trimStartInSeconds, trimEndInSeconds, playbackRate, }: ConvertAudioDataOptions) => PcmS16AudioData;
+export declare const fixFloatingPoint: (value: number) => number;
+export declare const convertAudioData: ({ audioData, trimStartInSeconds, trimEndInSeconds, playbackRate, audioDataTimestamp, isLast, }: ConvertAudioDataOptions) => PcmS16AudioData;

package/dist/convert-audiodata/convert-audiodata.js

@@ -1,6 +1,19 @@
 import { resampleAudioData, TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from './resample-audiodata';
 const FORMAT = 's16';
-export const convertAudioData = ({ audioData, trimStartInSeconds, trimEndInSeconds, playbackRate, }) => {
+export const fixFloatingPoint = (value) => {
+    if (value % 1 < 0.0000001) {
+        return Math.floor(value);
+    }
+    if (value % 1 > 0.9999999) {
+        return Math.ceil(value);
+    }
+    return value;
+};
+const ceilButNotIfFloatingPointIssue = (value) => {
+    const fixed = fixFloatingPoint(value);
+    return Math.ceil(fixed);
+};
+export const convertAudioData = ({ audioData, trimStartInSeconds, trimEndInSeconds, playbackRate, audioDataTimestamp, isLast, }) => {
     const { numberOfChannels: srcNumberOfChannels, sampleRate: currentSampleRate, numberOfFrames, } = audioData;
     const ratio = currentSampleRate / TARGET_SAMPLE_RATE;
     // Always rounding down start timestamps and rounding up end durations
@@ -9,11 +22,14 @@ export const convertAudioData = ({ audioData, trimStartInSeconds, trimEndInSecon
     // timestamp and round up the end timestamp
     // This might lead to overlapping, hopefully aligning perfectly!
     // Test case: https://github.com/remotion-dev/remotion/issues/5758
-    const frameOffset = Math.floor(trimStartInSeconds * audioData.sampleRate);
-    const unroundedFrameCount = numberOfFrames -
-        (trimEndInSeconds + trimStartInSeconds) * audioData.sampleRate;
-    const frameCount = Math.ceil(unroundedFrameCount);
-    const newNumberOfFrames = Math.ceil(unroundedFrameCount / ratio / playbackRate);
+    const frameOffset = Math.floor(fixFloatingPoint(trimStartInSeconds * audioData.sampleRate));
+    const unroundedFrameCount = numberOfFrames - trimEndInSeconds * audioData.sampleRate - frameOffset;
+    const frameCount = isLast
+        ? ceilButNotIfFloatingPointIssue(unroundedFrameCount)
+        : Math.round(unroundedFrameCount);
+    const newNumberOfFrames = isLast
+        ? ceilButNotIfFloatingPointIssue(unroundedFrameCount / ratio / playbackRate)
+        : Math.round(unroundedFrameCount / ratio / playbackRate);
     if (newNumberOfFrames === 0) {
         throw new Error('Cannot resample - the given sample rate would result in less than 1 sample');
     }
@@ -26,13 +42,16 @@ export const convertAudioData = ({ audioData, trimStartInSeconds, trimEndInSecon
     });
     const data = new Int16Array(newNumberOfFrames * TARGET_NUMBER_OF_CHANNELS);
     const chunkSize = frameCount / newNumberOfFrames;
+    const timestampOffsetMicroseconds = (frameOffset / audioData.sampleRate) * 1000000;
     if (newNumberOfFrames === frameCount &&
         TARGET_NUMBER_OF_CHANNELS === srcNumberOfChannels &&
         playbackRate === 1) {
         return {
             data: srcChannels,
             numberOfFrames: newNumberOfFrames,
-            timestamp: audioData.timestamp + (frameOffset / audioData.sampleRate) * 1000000,
+            timestamp: audioDataTimestamp * 1000000 +
+                fixFloatingPoint(timestampOffsetMicroseconds),
+            durationInMicroSeconds: fixFloatingPoint((newNumberOfFrames / TARGET_SAMPLE_RATE) * 1000000),
         };
     }
     resampleAudioData({
@@ -45,7 +64,9 @@ export const convertAudioData = ({ audioData, trimStartInSeconds, trimEndInSecon
     const newAudioData = {
         data,
         numberOfFrames: newNumberOfFrames,
-        timestamp: audioData.timestamp + (frameOffset / audioData.sampleRate) * 1000000,
+        timestamp: audioDataTimestamp * 1000000 +
+            fixFloatingPoint(timestampOffsetMicroseconds),
+        durationInMicroSeconds: fixFloatingPoint((newNumberOfFrames / TARGET_SAMPLE_RATE) * 1000000),
     };
     return newAudioData;
 };

package/dist/debug-overlay/preview-overlay.js

@@ -11,7 +11,7 @@ export const drawPreviewOverlay = ({ context, audioTime, audioContextState, audi
     if (audioIteratorManager) {
         const queuedPeriod = audioIteratorManager
             .getAudioBufferIterator()
-            ?.getQueuedPeriod([]);
+            ?.getQueuedPeriod();
         const numberOfChunksAfterResuming = audioIteratorManager
             ?.getAudioBufferIterator()
             ?.getNumberOfChunksAfterResuming();