@remotion/media-utils 4.0.393 → 4.0.395

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-wave-data.d.ts

@@ -0,0 +1,12 @@
+export declare const getPartialWaveData: ({ dataOffset, src, bitsPerSample, channelIndex, sampleRate, fromSeconds, toSeconds, blockAlign, fileSize, signal, }: {
+    dataOffset: number;
+    src: string;
+    bitsPerSample: number;
+    channelIndex: number;
+    sampleRate: number;
+    fromSeconds: number;
+    toSeconds: number;
+    blockAlign: number;
+    fileSize: number;
+    signal: AbortSignal;
+}) => Promise<Float32Array<ArrayBuffer>>;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPartialWaveData = void 0;
+const fetch_with_cors_catch_1 = require("./fetch-with-cors-catch");
+const probe_wave_file_1 = require("./probe-wave-file");
+const getPartialWaveData = async ({ dataOffset, src, bitsPerSample, channelIndex, sampleRate, fromSeconds, toSeconds, blockAlign, fileSize, signal, }) => {
+    const startByte = dataOffset + Math.floor(fromSeconds * sampleRate) * blockAlign;
+    const endByte = Math.min(fileSize, (dataOffset + Math.floor(toSeconds * sampleRate)) * blockAlign) - 1;
+    const response = await (0, fetch_with_cors_catch_1.fetchWithCorsCatch)(src, {
+        headers: {
+            range: `bytes=${startByte}-${endByte}`,
+        },
+        signal,
+    });
+    if (response.status === 416) {
+        throw new Error(`Tried to read bytes ${startByte}-${endByte} from ${src}, but the response status code was 416 "Range Not Satisfiable". Were too many bytes requested? The file is ${fileSize} bytes long.`);
+    }
+    if (response.status !== 206) {
+        throw new Error(`Tried to read bytes ${startByte}-${endByte} from ${src}, but the response status code was ${response.status} (expected was 206). This means the server might not support returning a partial response.`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const uintArray = new Uint8Array(arrayBuffer);
+    const samples = new Float32Array(uintArray.length / blockAlign);
+    for (let i = 0; i < uintArray.length; i += blockAlign) {
+        const sampleStart = i + channelIndex * (bitsPerSample / 8);
+        let sample;
+        if (bitsPerSample === 16) {
+            sample = (0, probe_wave_file_1.getInt16AsFloat)(uintArray, sampleStart);
+        }
+        else if (bitsPerSample === 8) {
+            sample = (0, probe_wave_file_1.getInt8AsFloat)(uintArray, sampleStart);
+        }
+        else {
+            throw new Error(`Unsupported bits per sample: ${bitsPerSample}`);
+        }
+        samples[i / blockAlign] = sample;
+    }
+    return samples;
+};
+exports.getPartialWaveData = getPartialWaveData;

package/dist/probe-wave-file.d.ts

@@ -0,0 +1,12 @@
+export declare const getInt16AsFloat: (bytes: Uint8Array, offset: number) => number;
+export declare const getInt8AsFloat: (bytes: Uint8Array, offset: number) => number;
+export type WaveProbe = {
+    dataOffset: number;
+    bitsPerSample: number;
+    numberOfChannels: number;
+    sampleRate: number;
+    blockAlign: number;
+    fileSize: number;
+    durationInSeconds: number;
+};
+export declare const probeWaveFile: (src: string, probeSize?: number) => Promise<WaveProbe>;

package/dist/probe-wave-file.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeWaveFile = exports.getInt8AsFloat = exports.getInt16AsFloat = void 0;
+const fetch_with_cors_catch_1 = require("./fetch-with-cors-catch");
+const getUint32 = (bytes, offset) => {
+    const val1 = bytes[offset + 3];
+    const val2 = bytes[offset + 2];
+    const val3 = bytes[offset + 1];
+    const val4 = bytes[offset];
+    return (val1 << 24) | (val2 << 16) | (val3 << 8) | val4;
+};
+const getUint16 = (bytes, offset) => {
+    const val1 = bytes[offset + 1];
+    const val2 = bytes[offset];
+    return (val1 << 8) | val2;
+};
+const getInt16AsFloat = (bytes, offset) => {
+    if (offset >= bytes.length) {
+        throw new Error(`Tried to read a 16-bit integer from offset ${offset} but the array length is ${bytes.length}`);
+    }
+    const val1 = bytes[offset + 1];
+    const val2 = bytes[offset];
+    const int16 = (val1 << 8) | val2;
+    return ((int16 << 16) >> 16) / 32768;
+};
+exports.getInt16AsFloat = getInt16AsFloat;
+const getInt8AsFloat = (bytes, offset) => {
+    if (offset >= bytes.length) {
+        throw new Error(`Tried to read an 8-bit integer from offset ${offset} but the array length is ${bytes.length}`);
+    }
+    return bytes[offset] / 128;
+};
+exports.getInt8AsFloat = getInt8AsFloat;
+const probeWaveFile = async (src, probeSize = 1024) => {
+    const response = await (0, fetch_with_cors_catch_1.fetchWithCorsCatch)(src, {
+        headers: {
+            range: `bytes=0-${probeSize - 1}`,
+        },
+    });
+    if (response.status === 416) {
+        throw new Error(`Tried to read bytes 0-1024 from ${src}, but the response status code was 416 "Range Not Satisfiable". Is the file at least 256 bytes long?`);
+    }
+    if (response.status !== 206) {
+        throw new Error(`Tried to read bytes 0-1024 from ${src}, but the response status code was ${response.status} (expected was 206). This means the server might not support returning a partial response.`);
+    }
+    const buffer = await response.arrayBuffer();
+    const uintArray = new Uint8Array(buffer);
+    const shouldBeRiff = new TextDecoder().decode(uintArray.slice(0, 4));
+    if (shouldBeRiff !== 'RIFF') {
+        throw new Error('getPartialAudioData() requires a WAVE file, but the first bytes are not RIFF. ');
+    }
+    const size = getUint32(uintArray, 4);
+    const shouldBeWAVE = new TextDecoder().decode(uintArray.slice(8, 12));
+    if (shouldBeWAVE !== 'WAVE') {
+        throw new Error('getPartialAudioData() requires a WAVE file, but the bytes 8-11 are not "WAVE". ');
+    }
+    const shouldBeFmt = new TextDecoder().decode(uintArray.slice(12, 16));
+    if (shouldBeFmt !== 'fmt ') {
+        throw new Error('getPartialAudioData() requires a WAVE file, but the bytes 12-15 are not "fmt ". ');
+    }
+    // const chunkSize = toUint32(uintArray.slice(16, 20));
+    const audioFormat = getUint16(uintArray, 20);
+    if (audioFormat !== 1) {
+        throw new Error('getPartialAudioData() supports only a WAVE file with PCM audio format, but the audio format is not PCM. ');
+    }
+    const numberOfChannels = getUint16(uintArray, 22);
+    const sampleRate = getUint32(uintArray, 24);
+    const blockAlign = getUint16(uintArray, 32);
+    const bitsPerSample = getUint16(uintArray, 34);
+    let offset = 36;
+    const shouldBeDataOrList = new TextDecoder().decode(uintArray.slice(offset, offset + 4));
+    if (shouldBeDataOrList === 'LIST') {
+        const listSize = getUint32(uintArray, 40);
+        offset += listSize;
+        offset += 8;
+    }
+    if (offset + 4 > probeSize) {
+        return (0, exports.probeWaveFile)(src, offset + 4);
+    }
+    const shouldBeData = new TextDecoder().decode(uintArray.slice(offset, offset + 4));
+    if (shouldBeData !== 'data') {
+        throw new Error(`getPartialAudioData() requires a WAVE file, but the bytes ${offset}-${offset + 4} are not "data". `);
+    }
+    const dataSize = getUint32(uintArray, offset + 4);
+    return {
+        dataOffset: offset + 8,
+        bitsPerSample,
+        numberOfChannels,
+        sampleRate,
+        blockAlign,
+        fileSize: size,
+        durationInSeconds: dataSize / (sampleRate * blockAlign),
+    };
+};
+exports.probeWaveFile = probeWaveFile;

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.393",
+	"version": "4.0.395",
 	"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.393",
-		"@remotion/webcodecs": "4.0.393",
-		"remotion": "4.0.393",
-		"mediabunny": "1.27.0"
+		"@remotion/media-parser": "4.0.395",
+		"@remotion/webcodecs": "4.0.395",
+		"remotion": "4.0.395",
+		"mediabunny": "1.27.2"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.393",
+		"@remotion/eslint-config-internal": "4.0.395",
 		"eslint": "9.19.0"
 	},
 	"keywords": [