@remotion/media-utils 4.0.394 → 4.0.396

package/dist/get-partial-audio-data.d.ts

@@ -1,10 +1,9 @@
-import type { InputAudioTrack } from 'mediabunny';
 export type GetPartialAudioDataProps = {
-    track: InputAudioTrack;
     fromSeconds: number;
     toSeconds: number;
     channelIndex: number;
     signal: AbortSignal;
-    isMatroska?: boolean;
+    src: string;
+    isMatroska: boolean;
 };
-export declare const getPartialAudioData: ({ track, fromSeconds, toSeconds, channelIndex, signal, isMatroska, }: GetPartialAudioDataProps) => Promise<Float32Array>;
+export declare const getPartialAudioData: ({ fromSeconds, toSeconds, channelIndex, signal, src, isMatroska, }: GetPartialAudioDataProps) => Promise<Float32Array>;

package/dist/get-partial-audio-data.js

@@ -1,4 +1,56 @@
 "use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPartialAudioData = void 0;
 const mediabunny_1 = require("mediabunny");
@@ -6,43 +58,64 @@ const mediabunny_1 = require("mediabunny");
 // The worst case seems to be FLAC files with a 65'535 sample window, which would be 1486.0ms at 44.1Khz.
 // So let's set a threshold of 1.5 seconds.
 const EXTRA_THRESHOLD_IN_SECONDS = 1.5;
-const getPartialAudioData = async ({ track, fromSeconds, toSeconds, channelIndex, signal, isMatroska = false, }) => {
-    if (signal.aborted) {
-        throw new Error('Operation was aborted');
-    }
-    const audioSamples = [];
-    // matroska must be decoded from the start due to limitation
-    // https://www.remotion.dev/docs/media/support#matroska-limitation
-    // Also request extra data beforehand to handle audio frame dependencies
-    const actualFromSeconds = isMatroska
-        ? 0
-        : Math.max(0, fromSeconds - EXTRA_THRESHOLD_IN_SECONDS);
-    // mediabunny docs: constructing the sink is virtually free and does not perform any media data reads.
-    const sink = new mediabunny_1.AudioBufferSink(track);
-    for await (const { buffer, timestamp, duration } of sink.buffers(actualFromSeconds, toSeconds)) {
+const getPartialAudioData = async ({ fromSeconds, toSeconds, channelIndex, signal, src, isMatroska, }) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
         if (signal.aborted) {
-            break;
-        }
-        const channelData = buffer.getChannelData(channelIndex);
-        const bufferStartSeconds = timestamp;
-        const bufferEndSeconds = timestamp + duration;
-        const overlapStartSecond = Math.max(bufferStartSeconds, fromSeconds);
-        const overlapEndSecond = Math.min(bufferEndSeconds, toSeconds);
-        if (overlapStartSecond >= overlapEndSecond) {
-            continue;
-        }
-        const startSampleInBuffer = Math.floor((overlapStartSecond - bufferStartSeconds) * buffer.sampleRate);
-        const endSampleInBuffer = Math.ceil((overlapEndSecond - bufferStartSeconds) * buffer.sampleRate);
-        const trimmedData = channelData.slice(startSampleInBuffer, endSampleInBuffer);
-        audioSamples.push(trimmedData);
+            throw new Error('Operation was aborted');
+        }
+        const audioSamples = [];
+        // matroska must be decoded from the start due to limitation
+        // https://www.remotion.dev/docs/media/support#matroska-limitation
+        // Also request extra data beforehand to handle audio frame dependencies
+        const actualFromSeconds = isMatroska
+            ? 0
+            : Math.max(0, fromSeconds - EXTRA_THRESHOLD_IN_SECONDS);
+        const source = new mediabunny_1.UrlSource(src);
+        const input = __addDisposableResource(env_1, new mediabunny_1.Input({
+            formats: mediabunny_1.ALL_FORMATS,
+            source,
+        }), false);
+        const track = await input.getPrimaryAudioTrack();
+        if (!track) {
+            throw new Error('No audio track found');
+        }
+        // mediabunny docs: constructing the sink is virtually free and does not perform any media data reads.
+        const sink = new mediabunny_1.AudioBufferSink(track);
+        const iterator = sink.buffers(actualFromSeconds, toSeconds);
+        for await (const { buffer, timestamp, duration } of iterator) {
+            if (signal.aborted) {
+                break;
+            }
+            const channelData = buffer.getChannelData(channelIndex);
+            const bufferStartSeconds = timestamp;
+            const bufferEndSeconds = timestamp + duration;
+            const overlapStartSecond = Math.max(bufferStartSeconds, fromSeconds);
+            const overlapEndSecond = Math.min(bufferEndSeconds, toSeconds);
+            if (overlapStartSecond >= overlapEndSecond) {
+                continue;
+            }
+            const startSampleInBuffer = Math.floor((overlapStartSecond - bufferStartSeconds) * buffer.sampleRate);
+            const endSampleInBuffer = Math.ceil((overlapEndSecond - bufferStartSeconds) * buffer.sampleRate);
+            const trimmedData = channelData.slice(startSampleInBuffer, endSampleInBuffer);
+            audioSamples.push(trimmedData);
+        }
+        await iterator.return();
+        const totalSamples = audioSamples.reduce((sum, sample) => sum + sample.length, 0);
+        const result = new Float32Array(totalSamples);
+        let offset = 0;
+        for (const audioSample of audioSamples) {
+            result.set(audioSample, offset);
+            offset += audioSample.length;
+        }
+        return result;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
-    const totalSamples = audioSamples.reduce((sum, sample) => sum + sample.length, 0);
-    const result = new Float32Array(totalSamples);
-    let offset = 0;
-    for (const audioSample of audioSamples) {
-        result.set(audioSample, offset);
-        offset += audioSample.length;
+    finally {
+        __disposeResources(env_1);
     }
-    return result;
 };
 exports.getPartialAudioData = getPartialAudioData;

package/dist/get-partial-media-data-2.d.ts

@@ -0,0 +1,7 @@
+export declare const getPartialMediaData: ({ src, fromSeconds, toSeconds, channelIndex, signal, }: {
+    src: string;
+    fromSeconds: number;
+    toSeconds: number;
+    channelIndex: number;
+    signal: AbortSignal;
+}) => Promise<Float32Array>;

package/dist/get-partial-media-data-2.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPartialMediaData = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const webcodecs_1 = require("@remotion/webcodecs");
+const getPartialMediaData = async ({ src, fromSeconds, toSeconds, channelIndex, signal, }) => {
+    const controller = (0, media_parser_1.mediaParserController)();
+    // Collect audio samples
+    const audioSamples = [];
+    // Abort if the signal is already aborted
+    if (signal.aborted) {
+        throw new Error('Operation was aborted');
+    }
+    try {
+        if (fromSeconds > 0) {
+            controller.seek(fromSeconds);
+        }
+        await (0, media_parser_1.parseMedia)({
+            src,
+            controller,
+            onAudioTrack: ({ track }) => {
+                if (!track) {
+                    throw new Error('No audio track found');
+                }
+                const audioDecoder = (0, webcodecs_1.createAudioDecoder)({
+                    track,
+                    onFrame: (sample) => {
+                        if (signal.aborted) {
+                            sample.close();
+                            return;
+                        }
+                        // For multi-channel audio, we need to handle channels properly
+                        const { numberOfChannels } = sample;
+                        const samplesPerChannel = sample.numberOfFrames;
+                        let data;
+                        if (numberOfChannels === 1) {
+                            // Mono audio
+                            data = new Float32Array(sample.allocationSize({ format: 'f32', planeIndex: 0 }));
+                            sample.copyTo(data, { format: 'f32', planeIndex: 0 });
+                        }
+                        else {
+                            // Multi-channel audio: extract specific channel
+                            const allChannelsData = new Float32Array(sample.allocationSize({ format: 'f32', planeIndex: 0 }));
+                            sample.copyTo(allChannelsData, { format: 'f32', planeIndex: 0 });
+                            // Extract the specific channel (interleaved audio)
+                            data = new Float32Array(samplesPerChannel);
+                            for (let i = 0; i < samplesPerChannel; i++) {
+                                data[i] = allChannelsData[i * numberOfChannels + channelIndex];
+                            }
+                        }
+                        audioSamples.push(data);
+                        sample.close();
+                    },
+                    onError(error) {
+                        throw error;
+                    },
+                });
+                // Listen for abort signal
+                const onAbort = () => {
+                    controller.abort();
+                    if (audioDecoder) {
+                        audioDecoder.close();
+                    }
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                return async (sample) => {
+                    if (signal.aborted) {
+                        return;
+                    }
+                    // Convert timestamp using the track's timescale
+                    const time = sample.timestamp / track.timescale;
+                    console.log(time);
+                    // Stop immediately when we reach our target time
+                    if (time >= toSeconds) {
+                        // abort media parsing, we reached the point where we want to stop
+                        controller.abort();
+                        return;
+                    }
+                    // Decode the sample using the sample directly
+                    await audioDecoder.waitForQueueToBeLessThan(10);
+                    // we're waiting for the queue above anyway, enqueue in sync mode
+                    audioDecoder.decode(sample);
+                };
+            },
+        });
+    }
+    catch (err) {
+        const isAbortedByTimeCutoff = (0, media_parser_1.hasBeenAborted)(err);
+        // Don't throw if we stopped the parsing ourselves
+        if (!isAbortedByTimeCutoff && !signal.aborted) {
+            throw err;
+        }
+    }
+    // Simply concatenate all audio data since windowing handles the time ranges
+    const totalSamples = audioSamples.reduce((sum, sample) => sum + sample.length, 0);
+    const result = new Float32Array(totalSamples);
+    let offset = 0;
+    for (const audioSample of audioSamples) {
+        result.set(audioSample, offset);
+        offset += audioSample.length;
+    }
+    return result;
+};
+exports.getPartialMediaData = getPartialMediaData;

package/dist/get-partial-media-data.d.ts

@@ -0,0 +1,7 @@
+export declare const getPartialMediaData: ({ src, fromSeconds, toSeconds, channelIndex, signal, }: {
+    src: string;
+    fromSeconds: number;
+    toSeconds: number;
+    channelIndex: number;
+    signal: AbortSignal;
+}) => Promise<Float32Array>;

package/dist/get-partial-media-data.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPartialMediaData = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const worker_1 = require("@remotion/media-parser/worker");
+const webcodecs_1 = require("@remotion/webcodecs");
+const getPartialMediaData = async ({ src, fromSeconds, toSeconds, channelIndex, signal, }) => {
+    const controller = (0, media_parser_1.mediaParserController)();
+    // Collect audio samples
+    const audioSamples = [];
+    // Abort if the signal is already aborted
+    if (signal.aborted) {
+        throw new Error('Operation was aborted');
+    }
+    try {
+        if (fromSeconds > 0) {
+            controller.seek(fromSeconds);
+        }
+        await (0, worker_1.parseMediaOnWebWorker)({
+            src,
+            controller,
+            onAudioTrack: ({ track }) => {
+                if (!track) {
+                    throw new Error('No audio track found');
+                }
+                const audioDecoder = (0, webcodecs_1.createAudioDecoder)({
+                    track,
+                    onFrame: (sample) => {
+                        if (signal.aborted) {
+                            sample.close();
+                            return;
+                        }
+                        // For multi-channel audio, we need to handle channels properly
+                        const { numberOfChannels } = sample;
+                        const samplesPerChannel = sample.numberOfFrames;
+                        let data;
+                        if (numberOfChannels === 1) {
+                            // Mono audio
+                            data = new Float32Array(sample.allocationSize({ format: 'f32', planeIndex: 0 }));
+                            sample.copyTo(data, { format: 'f32', planeIndex: 0 });
+                        }
+                        else {
+                            // Multi-channel audio: extract specific channel
+                            const allChannelsData = new Float32Array(sample.allocationSize({ format: 'f32', planeIndex: 0 }));
+                            sample.copyTo(allChannelsData, { format: 'f32', planeIndex: 0 });
+                            // Extract the specific channel (interleaved audio)
+                            data = new Float32Array(samplesPerChannel);
+                            for (let i = 0; i < samplesPerChannel; i++) {
+                                data[i] = allChannelsData[i * numberOfChannels + channelIndex];
+                            }
+                        }
+                        audioSamples.push(data);
+                        sample.close();
+                    },
+                    onError(error) {
+                        throw error;
+                    },
+                });
+                // Listen for abort signal
+                const onAbort = () => {
+                    controller.abort();
+                    if (audioDecoder) {
+                        audioDecoder.close();
+                    }
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+                return async (sample) => {
+                    if (signal.aborted) {
+                        return;
+                    }
+                    // Convert timestamp using the track's timescale
+                    const time = sample.timestamp / track.timescale;
+                    // Stop immediately when we reach our target time
+                    if (time >= toSeconds) {
+                        // abort media parsing, we reached the point where we want to stop
+                        controller.abort();
+                        await audioDecoder.flush();
+                        return;
+                    }
+                    // Decode the sample using the sample directly
+                    await audioDecoder.waitForQueueToBeLessThan(10);
+                    // we're waiting for the queue above anyway, enqueue in sync mode
+                    audioDecoder.decode(sample);
+                };
+            },
+        });
+    }
+    catch (err) {
+        const isAbortedByTimeCutoff = (0, media_parser_1.hasBeenAborted)(err);
+        // Don't throw if we stopped the parsing ourselves
+        if (!isAbortedByTimeCutoff && !signal.aborted) {
+            throw err;
+        }
+    }
+    // Simply concatenate all audio data since windowing handles the time ranges
+    const totalSamples = audioSamples.reduce((sum, sample) => sum + sample.length, 0);
+    const result = new Float32Array(totalSamples);
+    let offset = 0;
+    for (const audioSample of audioSamples) {
+        result.set(audioSample, offset);
+        offset += audioSample.length;
+    }
+    return result;
+};
+exports.getPartialMediaData = getPartialMediaData;

package/dist/use-windowed-audio-data.js

@@ -1,4 +1,56 @@
 "use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useWindowedAudioData = void 0;
 const mediabunny_1 = require("mediabunny");
@@ -28,63 +80,68 @@ const useWindowedAudioData = ({ src, frame, fps, windowInSeconds, channelIndex =
             });
             requests.current = {};
             setWaveformMap({});
-            if (audioUtils) {
-                audioUtils.input.dispose();
-            }
         };
     }, [audioUtils]);
     const { delayRender, continueRender } = (0, remotion_1.useDelayRender)();
     const fetchMetadata = (0, react_1.useCallback)(async (signal) => {
-        const handle = delayRender(`Waiting for audio metadata with src="${src}" to be loaded`);
-        const cont = () => {
-            continueRender(handle);
-        };
-        signal.addEventListener('abort', cont, { once: true });
-        const input = new mediabunny_1.Input({
-            formats: mediabunny_1.ALL_FORMATS,
-            source: new mediabunny_1.UrlSource(src),
-        });
-        const onAbort = () => {
-            input.dispose();
-        };
-        signal.addEventListener('abort', onAbort, { once: true });
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const durationInSeconds = await input.computeDuration();
-            const audioTrack = await input.getPrimaryAudioTrack();
-            if (!audioTrack) {
-                throw new Error('No audio track found');
-            }
-            const canDecode = await audioTrack.canDecode();
-            if (!canDecode) {
-                throw new Error('Audio track cannot be decoded');
+            const handle = delayRender(`Waiting for audio metadata with src="${src}" to be loaded`);
+            const cont = () => {
+                continueRender(handle);
+            };
+            signal.addEventListener('abort', cont, { once: true });
+            const source = new mediabunny_1.UrlSource(src);
+            const input = __addDisposableResource(env_1, new mediabunny_1.Input({
+                formats: mediabunny_1.ALL_FORMATS,
+                source,
+            }), false);
+            const onAbort = () => {
+                input.dispose();
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            try {
+                const durationInSeconds = await input.computeDuration();
+                const audioTrack = await input.getPrimaryAudioTrack();
+                if (!audioTrack) {
+                    throw new Error('No audio track found');
+                }
+                const canDecode = await audioTrack.canDecode();
+                if (!canDecode) {
+                    throw new Error('Audio track cannot be decoded');
+                }
+                if (channelIndex >= audioTrack.numberOfChannels || channelIndex < 0) {
+                    throw new Error(`Invalid channel index ${channelIndex} for audio with ${audioTrack.numberOfChannels} channels`);
+                }
+                const { numberOfChannels, sampleRate } = audioTrack;
+                const format = await input.getFormat();
+                const isMatroska = format === mediabunny_1.MATROSKA || format === mediabunny_1.WEBM;
+                if (isMounted.current) {
+                    setAudioUtils({
+                        metadata: {
+                            durationInSeconds,
+                            numberOfChannels,
+                            sampleRate,
+                        },
+                        isMatroska,
+                    });
+                }
+                continueRender(handle);
             }
-            if (channelIndex >= audioTrack.numberOfChannels || channelIndex < 0) {
-                throw new Error(`Invalid channel index ${channelIndex} for audio with ${audioTrack.numberOfChannels} channels`);
+            catch (err) {
+                (0, remotion_1.cancelRender)(err);
             }
-            const { numberOfChannels, sampleRate } = audioTrack;
-            const format = await input.getFormat();
-            const isMatroska = format === mediabunny_1.MATROSKA || format === mediabunny_1.WEBM;
-            if (isMounted.current) {
-                setAudioUtils({
-                    input,
-                    track: audioTrack,
-                    metadata: {
-                        durationInSeconds,
-                        numberOfChannels,
-                        sampleRate,
-                    },
-                    isMatroska,
-                });
+            finally {
+                signal.removeEventListener('abort', cont);
+                signal.removeEventListener('abort', onAbort);
             }
-            continueRender(handle);
         }
-        catch (err) {
-            input.dispose();
-            (0, remotion_1.cancelRender)(err);
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
         finally {
-            signal.removeEventListener('abort', cont);
-            signal.removeEventListener('abort', onAbort);
+            __disposeResources(env_1);
         }
     }, [src, delayRender, continueRender, channelIndex]);
     (0, react_1.useLayoutEffect)(() => {
@@ -112,7 +169,7 @@ const useWindowedAudioData = ({ src, frame, fps, windowInSeconds, channelIndex =
         ]
             .filter((i) => i !== null)
             .filter((i) => i >= 0);
-    }, [currentWindowIndex, audioUtils === null || audioUtils === void 0 ? void 0 : audioUtils.metadata, windowInSeconds]);
+    }, [currentWindowIndex, audioUtils, windowInSeconds]);
     const fetchAndSetWaveformData = (0, react_1.useCallback)(async (windowIndex) => {
         if (!(audioUtils === null || audioUtils === void 0 ? void 0 : audioUtils.metadata) || !audioUtils) {
             throw new Error('MediaBunny context is not loaded yet');
@@ -141,7 +198,7 @@ const useWindowedAudioData = ({ src, frame, fps, windowInSeconds, channelIndex =
                 remotion_1.Internals.Log.warn({ logLevel: 'info', tag: '@remotion/media-utils' }, `[useWindowedAudioData] Matroska/WebM file detected at "${src}".\n\nDue to format limitation, audio decoding must start from the beginning of the file, which may lead to increased memory usage and slower performance for large files. Consider converting the audio to a more suitable format like MP3 or AAC for better performance.`);
             }
             const partialWaveData = await (0, get_partial_audio_data_1.getPartialAudioData)({
-                track: audioUtils.track,
+                src,
                 fromSeconds,
                 toSeconds,
                 channelIndex,
@@ -191,7 +248,7 @@ const useWindowedAudioData = ({ src, frame, fps, windowInSeconds, channelIndex =
             }
         }
         // Only fetch windows that don't already exist
-        const windowsToActuallyFetch = windowsToFetch.filter((windowIndex) => !waveFormMap[windowIndex]);
+        const windowsToActuallyFetch = windowsToFetch.filter((windowIndex) => !waveFormMap[windowIndex] && !requests.current[windowIndex]);
         if (windowsToActuallyFetch.length === 0) {
             return;
         }
@@ -233,7 +290,7 @@ const useWindowedAudioData = ({ src, frame, fps, windowInSeconds, channelIndex =
             resultId: `${src}-windows-${availableWindows.join(',')}`,
             sampleRate: audioUtils.metadata.sampleRate,
         };
-    }, [src, waveFormMap, audioUtils === null || audioUtils === void 0 ? void 0 : audioUtils.metadata, availableWindows]);
+    }, [src, waveFormMap, audioUtils, availableWindows]);
     const isBeyondAudioDuration = audioUtils
         ? currentTime >= audioUtils.metadata.durationInSeconds
         : false;

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-utils"
 	},
 	"name": "@remotion/media-utils",
-	"version": "4.0.394",
+	"version": "4.0.396",
 	"description": "Utilities for working with media files",
 	"main": "dist/index.js",
 	"sideEffects": false,
@@ -18,17 +18,17 @@
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
 	"dependencies": {
-		"@remotion/media-parser": "4.0.394",
-		"@remotion/webcodecs": "4.0.394",
-		"remotion": "4.0.394",
-		"mediabunny": "1.27.0"
+		"@remotion/media-parser": "4.0.396",
+		"@remotion/webcodecs": "4.0.396",
+		"remotion": "4.0.396",
+		"mediabunny": "1.27.2"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.394",
+		"@remotion/eslint-config-internal": "4.0.396",
 		"eslint": "9.19.0"
 	},
 	"keywords": [