@remotion/media 4.0.429 → 4.0.430

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

@@ -1,7 +1,7 @@
 import type { InputAudioTrack, WrappedAudioBuffer } from 'mediabunny';
 import type { DelayPlaybackIfNotPremounting } from './delay-playback-if-not-premounting';
 import type { Nonce } from './nonce-manager';
-export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getIsLooping, getEndTime, getStartTime, updatePlaybackTime, initialMuted, drawDebugOverlay, }: {
+export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getIsLooping, getEndTime, getStartTime, initialMuted, drawDebugOverlay, }: {
     audioTrack: InputAudioTrack;
     delayPlaybackHandleIfNotPremounting: () => DelayPlaybackIfNotPremounting;
     sharedAudioContext: AudioContext;
@@ -9,7 +9,6 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
     getEndTime: () => number;
     getStartTime: () => number;
     initialMuted: boolean;
-    updatePlaybackTime: (time: number) => void;
     drawDebugOverlay: () => void;
 }) => {
     startAudioIterator: ({ nonce, playbackRate, startFromSecond, getIsPlaying, scheduleAudioNode, }: {
@@ -17,22 +16,23 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
         nonce: Nonce;
         playbackRate: number;
         getIsPlaying: () => boolean;
-        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
     }) => Promise<void>;
     resumeScheduledAudioChunks: ({ playbackRate, scheduleAudioNode, }: {
         playbackRate: number;
-        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
     }) => void;
     pausePlayback: () => void;
     getAudioBufferIterator: () => {
         destroy: () => void;
         getNext: () => Promise<IteratorResult<WrappedAudioBuffer, void>>;
         isDestroyed: () => boolean;
-        addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer) => void;
+        addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer, maxDuration: number | null) => void;
         removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
         getAndClearAudioChunksForAfterResuming: () => {
             buffer: AudioBuffer;
             timestamp: number;
+            maxDuration: number | null;
         }[];
         getQueuedPeriod: () => {
             from: number;
@@ -53,7 +53,7 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
         } | {
             type: "max-reached";
         }>;
-        addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
+        addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number, maxDuration: number | null) => void;
         moveQueuedChunksToPauseQueue: () => void;
         getNumberOfChunksAfterResuming: () => number;
     } | null;
@@ -63,16 +63,17 @@ export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfN
         nonce: Nonce;
         playbackRate: number;
         getIsPlaying: () => boolean;
-        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
     }) => Promise<void>;
     getAudioIteratorsCreated: () => number;
     setMuted: (newMuted: boolean) => void;
     setVolume: (volume: number) => void;
-    scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, }: {
+    scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, maxDuration, }: {
         buffer: AudioBuffer;
         mediaTimestamp: number;
         playbackRate: number;
-        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+        scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
+        maxDuration: number | null;
     }) => void;
 };
 export type AudioIteratorManager = ReturnType<typeof audioIteratorManager>;

package/dist/audio-iterator-manager.js

@@ -0,0 +1,228 @@
+import { AudioBufferSink, InputDisposedError } from 'mediabunny';
+import { isAlreadyQueued, makeAudioIterator, } from './audio/audio-preview-iterator';
+import { makePrewarmedAudioIteratorCache } from './prewarm-iterator-for-looping';
+export const audioIteratorManager = ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getIsLooping, getEndTime, getStartTime, updatePlaybackTime, }) => {
+    let muted = false;
+    let currentVolume = 1;
+    const gainNode = sharedAudioContext.createGain();
+    gainNode.connect(sharedAudioContext.destination);
+    const audioSink = new AudioBufferSink(audioTrack);
+    const prewarmedAudioIteratorCache = makePrewarmedAudioIteratorCache(audioSink);
+    let audioBufferIterator = null;
+    let audioIteratorsCreated = 0;
+    let currentDelayHandle = null;
+    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, }) => {
+        updatePlaybackTime(startFromSecond);
+        audioBufferIterator?.destroy();
+        const delayHandle = delayPlaybackHandleIfNotPremounting();
+        currentDelayHandle = delayHandle;
+        const iterator = makeAudioIterator(startFromSecond, prewarmedAudioIteratorCache);
+        audioIteratorsCreated++;
+        audioBufferIterator = iterator;
+        try {
+            // 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()) {
+                    return;
+                }
+                if (nonce.isStale()) {
+                    return;
+                }
+                if (!result.value) {
+                    // media ended
+                    return;
+                }
+                onAudioChunk({
+                    getIsPlaying,
+                    buffer: result.value,
+                    playbackRate,
+                    scheduleAudioNode,
+                });
+            }
+        }
+        catch (e) {
+            if (e instanceof InputDisposedError) {
+                // iterator was disposed by a newer startAudioIterator call
+                // this is expected during rapid seeking
+                return;
+            }
+            throw e;
+        }
+        finally {
+            delayHandle.unblock();
+            currentDelayHandle = null;
+        }
+    };
+    const pausePlayback = () => {
+        if (!audioBufferIterator) {
+            return;
+        }
+        audioBufferIterator.moveQueuedChunksToPauseQueue();
+    };
+    const seek = async ({ newTime, nonce, fps, playbackRate, getIsPlaying, scheduleAudioNode, bufferState, }) => {
+        if (getIsLooping()) {
+            // If less than 1 second from the end away, we pre-warm a new iterator
+            if (getEndTime() - newTime < 1) {
+                prewarmedAudioIteratorCache.prewarmIteratorForLooping({
+                    timeToSeek: getStartTime(),
+                });
+            }
+        }
+        if (!audioBufferIterator) {
+            await startAudioIterator({
+                nonce,
+                playbackRate,
+                startFromSecond: newTime,
+                getIsPlaying,
+                scheduleAudioNode,
+            });
+            return;
+        }
+        const queuedPeriod = audioBufferIterator.getQueuedPeriod();
+        const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, queuedPeriod);
+        if (!currentTimeIsAlreadyQueued) {
+            const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(newTime, null, (buffer) => {
+                if (!nonce.isStale()) {
+                    onAudioChunk({
+                        getIsPlaying,
+                        buffer,
+                        playbackRate,
+                        scheduleAudioNode,
+                    });
+                }
+            });
+            if (nonce.isStale()) {
+                return;
+            }
+            if (audioSatisfyResult.type === 'ended') {
+                return;
+            }
+            if (audioSatisfyResult.type === 'not-satisfied') {
+                await startAudioIterator({
+                    nonce,
+                    playbackRate,
+                    startFromSecond: newTime,
+                    getIsPlaying,
+                    scheduleAudioNode,
+                });
+                return;
+            }
+        }
+        const nextTime = newTime +
+            // 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, {
+                type: 'allow-wait',
+                waitCallback: () => {
+                    const handle = bufferState.delayPlayback();
+                    return () => {
+                        handle.unblock();
+                    };
+                },
+            }, (buffer) => {
+                if (!nonce.isStale()) {
+                    onAudioChunk({
+                        getIsPlaying,
+                        buffer,
+                        playbackRate,
+                        scheduleAudioNode,
+                    });
+                }
+            });
+            if (nonce.isStale()) {
+                return;
+            }
+            if (audioSatisfyResult.type === 'ended') {
+                return;
+            }
+            if (audioSatisfyResult.type === 'not-satisfied') {
+                await startAudioIterator({
+                    nonce,
+                    playbackRate,
+                    startFromSecond: newTime,
+                    getIsPlaying,
+                    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,
+        destroyIterator: () => {
+            prewarmedAudioIteratorCache.destroy();
+            audioBufferIterator?.destroy();
+            audioBufferIterator = null;
+            if (currentDelayHandle) {
+                currentDelayHandle.unblock();
+                currentDelayHandle = 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/browser-can-use-webgl2.js

@@ -0,0 +1,13 @@
+let browserCanUseWebGl2 = null;
+const browserCanUseWebGl2Uncached = () => {
+    const canvas = new OffscreenCanvas(1, 1);
+    const context = canvas.getContext('webgl2');
+    return context !== null;
+};
+export const canBrowserUseWebGl2 = () => {
+    if (browserCanUseWebGl2 !== null) {
+        return browserCanUseWebGl2;
+    }
+    browserCanUseWebGl2 = browserCanUseWebGl2Uncached();
+    return browserCanUseWebGl2;
+};

package/dist/caches.js

@@ -0,0 +1,61 @@
+import React from 'react';
+import { cancelRender, Internals } from 'remotion';
+import { makeAudioManager } from './audio-extraction/audio-manager';
+import { makeKeyframeManager } from './video-extraction/keyframe-manager';
+// TODO: make it dependent on the fps and concurrency
+export const SAFE_BACK_WINDOW_IN_SECONDS = 1;
+export const keyframeManager = makeKeyframeManager();
+export const audioManager = makeAudioManager();
+export const getTotalCacheStats = async () => {
+    const keyframeManagerCacheStats = await keyframeManager.getCacheStats();
+    const audioManagerCacheStats = audioManager.getCacheStats();
+    return {
+        count: keyframeManagerCacheStats.count + audioManagerCacheStats.count,
+        totalSize: keyframeManagerCacheStats.totalSize + audioManagerCacheStats.totalSize,
+    };
+};
+const getUncachedMaxCacheSize = (logLevel) => {
+    if (typeof window !== 'undefined' &&
+        window.remotion_mediaCacheSizeInBytes !== undefined &&
+        window.remotion_mediaCacheSizeInBytes !== null) {
+        if (window.remotion_mediaCacheSizeInBytes < 240 * 1024 * 1024) {
+            cancelRender(new Error(`The minimum value for the "mediaCacheSizeInBytes" prop is 240MB (${240 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
+        }
+        if (window.remotion_mediaCacheSizeInBytes > 20000 * 1024 * 1024) {
+            cancelRender(new Error(`The maximum value for the "mediaCacheSizeInBytes" prop is 20GB (${20000 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
+        }
+        Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set using "mediaCacheSizeInBytes": ${(window.remotion_mediaCacheSizeInBytes / 1024 / 1024).toFixed(1)} MB`);
+        return window.remotion_mediaCacheSizeInBytes;
+    }
+    if (typeof window !== 'undefined' &&
+        window.remotion_initialMemoryAvailable !== undefined &&
+        window.remotion_initialMemoryAvailable !== null) {
+        const value = window.remotion_initialMemoryAvailable / 2;
+        if (value < 500 * 1024 * 1024) {
+            Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set based on minimum value of 500MB (which is more than half of the available system memory!)`);
+            return 500 * 1024 * 1024;
+        }
+        if (value > 20000 * 1024 * 1024) {
+            Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set based on maximum value of 20GB (which is less than half of the available system memory)`);
+            return 20000 * 1024 * 1024;
+        }
+        Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Using cache size set based on available memory (50% of available memory): ${(value / 1024 / 1024).toFixed(1)} MB`);
+        return value;
+    }
+    return 1000 * 1000 * 1000; // 1GB
+};
+let cachedMaxCacheSize = null;
+export const getMaxVideoCacheSize = (logLevel) => {
+    if (cachedMaxCacheSize !== null) {
+        return cachedMaxCacheSize;
+    }
+    cachedMaxCacheSize = getUncachedMaxCacheSize(logLevel);
+    return cachedMaxCacheSize;
+};
+export const useMaxMediaCacheSize = (logLevel) => {
+    const context = React.useContext(Internals.MaxMediaCacheSizeContext);
+    if (context === null) {
+        return getMaxVideoCacheSize(logLevel);
+    }
+    return context;
+};

package/dist/calculate-playbacktime.js

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

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

@@ -0,0 +1,17 @@
+export const applyVolume = (array, volume) => {
+    if (volume === 1) {
+        return;
+    }
+    for (let i = 0; i < array.length; i++) {
+        const newValue = array[i] * volume;
+        if (newValue < -32768) {
+            array[i] = -32768;
+        }
+        else if (newValue > 32767) {
+            array[i] = 32767;
+        }
+        else {
+            array[i] = newValue;
+        }
+    }
+};

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

@@ -0,0 +1,23 @@
+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;
+    for (const audioData of audioDataArray) {
+        arr.set(audioData.data, offset);
+        offset += audioData.data.length;
+    }
+    return {
+        data: arr,
+        numberOfFrames,
+        timestamp: fixFloatingPoint(timestamp),
+        durationInMicroSeconds: fixFloatingPoint(durationInMicroSeconds),
+    };
+};

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

@@ -0,0 +1,73 @@
+import { resampleAudioData, TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from './resample-audiodata';
+const FORMAT = 's16';
+export const fixFloatingPoint = (value) => {
+    const decimal = Math.abs(value % 1);
+    if (decimal < 0.0000001) {
+        return value < 0 ? Math.ceil(value) : Math.floor(value);
+    }
+    if (decimal > 0.9999999) {
+        return value < 0 ? Math.floor(value) : 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
+    // to ensure there are no gaps when the samples don't align
+    // In @remotion/renderer inline audio mixing, we also round down the sample start
+    // 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(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');
+    }
+    const srcChannels = new Int16Array(srcNumberOfChannels * frameCount);
+    audioData.copyTo(srcChannels, {
+        planeIndex: 0,
+        format: FORMAT,
+        frameOffset,
+        frameCount,
+    });
+    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: audioDataTimestamp * 1000000 +
+                fixFloatingPoint(timestampOffsetMicroseconds),
+            durationInMicroSeconds: fixFloatingPoint((newNumberOfFrames / TARGET_SAMPLE_RATE) * 1000000),
+        };
+    }
+    resampleAudioData({
+        srcNumberOfChannels,
+        sourceChannels: srcChannels,
+        destination: data,
+        targetFrames: newNumberOfFrames,
+        chunkSize,
+    });
+    const newAudioData = {
+        data,
+        numberOfFrames: newNumberOfFrames,
+        timestamp: audioDataTimestamp * 1000000 +
+            fixFloatingPoint(timestampOffsetMicroseconds),
+        durationInMicroSeconds: fixFloatingPoint((newNumberOfFrames / TARGET_SAMPLE_RATE) * 1000000),
+    };
+    return newAudioData;
+};

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

@@ -0,0 +1,94 @@
+// Remotion exports all videos with 2 channels.
+export const TARGET_NUMBER_OF_CHANNELS = 2;
+// Remotion exports all videos with 48kHz sample rate.
+export const TARGET_SAMPLE_RATE = 48000;
+const fixFloatingPoint = (value) => {
+    if (value % 1 < 0.0000001) {
+        return Math.floor(value);
+    }
+    if (value % 1 > 0.9999999) {
+        return Math.ceil(value);
+    }
+    return value;
+};
+export const resampleAudioData = ({ srcNumberOfChannels, sourceChannels, destination, targetFrames, chunkSize, }) => {
+    const getSourceValues = (startUnfixed, endUnfixed, channelIndex) => {
+        const start = fixFloatingPoint(startUnfixed);
+        const end = fixFloatingPoint(endUnfixed);
+        const startFloor = Math.floor(start);
+        const startCeil = Math.ceil(start);
+        const startFraction = start - startFloor;
+        const endFraction = end - Math.floor(end);
+        const endFloor = Math.floor(end);
+        let weightedSum = 0;
+        let totalWeight = 0;
+        // Handle first fractional sample
+        if (startFraction > 0) {
+            const firstSample = sourceChannels[startFloor * srcNumberOfChannels + channelIndex];
+            weightedSum += firstSample * (1 - startFraction);
+            totalWeight += 1 - startFraction;
+        }
+        // Handle full samples
+        for (let k = startCeil; k < endFloor; k++) {
+            const num = sourceChannels[k * srcNumberOfChannels + channelIndex];
+            weightedSum += num;
+            totalWeight += 1;
+        }
+        // Handle last fractional sample
+        if (endFraction > 0) {
+            const lastSample = sourceChannels[endFloor * srcNumberOfChannels + channelIndex];
+            weightedSum += lastSample * endFraction;
+            totalWeight += endFraction;
+        }
+        const average = weightedSum / totalWeight;
+        return average;
+    };
+    for (let newFrameIndex = 0; newFrameIndex < targetFrames; newFrameIndex++) {
+        const start = newFrameIndex * chunkSize;
+        const end = start + chunkSize;
+        if (TARGET_NUMBER_OF_CHANNELS === srcNumberOfChannels) {
+            for (let i = 0; i < srcNumberOfChannels; i++) {
+                destination[newFrameIndex * srcNumberOfChannels + i] = getSourceValues(start, end, i);
+            }
+        }
+        // The following formulas were taken from Mediabunnys audio resampler:
+        // https://github.com/Vanilagy/mediabunny/blob/b9f7ab2fa2b9167784cbded044d466185308999f/src/conversion.ts
+        // Mono to Stereo: M -> L, M -> R
+        if (srcNumberOfChannels === 1) {
+            const m = getSourceValues(start, end, 0);
+            destination[newFrameIndex * 2 + 0] = m;
+            destination[newFrameIndex * 2 + 1] = m;
+        }
+        // Quad to Stereo: 0.5 * (L + SL), 0.5 * (R + SR)
+        else if (srcNumberOfChannels === 4) {
+            const l = getSourceValues(start, end, 0);
+            const r = getSourceValues(start, end, 1);
+            const sl = getSourceValues(start, end, 2);
+            const sr = getSourceValues(start, end, 3);
+            const l2 = 0.5 * (l + sl);
+            const r2 = 0.5 * (r + sr);
+            destination[newFrameIndex * 2 + 0] = l2;
+            destination[newFrameIndex * 2 + 1] = r2;
+        }
+        // 5.1 to Stereo: L + sqrt(1/2) * (C + SL), R + sqrt(1/2) * (C + SR)
+        else if (srcNumberOfChannels === 6) {
+            const l = getSourceValues(start, end, 0);
+            const r = getSourceValues(start, end, 1);
+            const c = getSourceValues(start, end, 2);
+            const sl = getSourceValues(start, end, 3);
+            const sr = getSourceValues(start, end, 4);
+            const sq = Math.sqrt(1 / 2);
+            const l2 = l + sq * (c + sl);
+            const r2 = r + sq * (c + sr);
+            destination[newFrameIndex * 2 + 0] = l2;
+            destination[newFrameIndex * 2 + 1] = r2;
+        }
+        // Discrete fallback: direct mapping with zero-fill or drop
+        else {
+            for (let i = 0; i < srcNumberOfChannels; i++) {
+                destination[newFrameIndex * TARGET_NUMBER_OF_CHANNELS + i] =
+                    getSourceValues(start, end, i);
+            }
+        }
+    }
+};

package/dist/debug-overlay/preview-overlay.d.ts

@@ -10,22 +10,23 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
             nonce: import("../nonce-manager").Nonce;
             playbackRate: number;
             getIsPlaying: () => boolean;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
         }) => Promise<void>;
         resumeScheduledAudioChunks: ({ playbackRate, scheduleAudioNode, }: {
             playbackRate: number;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
         }) => void;
         pausePlayback: () => void;
         getAudioBufferIterator: () => {
             destroy: () => void;
             getNext: () => Promise<IteratorResult<import("mediabunny").WrappedAudioBuffer, void>>;
             isDestroyed: () => boolean;
-            addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer) => void;
+            addQueuedAudioNode: (node: AudioBufferSourceNode, timestamp: number, buffer: AudioBuffer, maxDuration: number | null) => void;
             removeQueuedAudioNode: (node: AudioBufferSourceNode) => void;
             getAndClearAudioChunksForAfterResuming: () => {
                 buffer: AudioBuffer;
                 timestamp: number;
+                maxDuration: number | null;
             }[];
             getQueuedPeriod: () => {
                 from: number;
@@ -46,7 +47,7 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
             } | {
                 type: "max-reached";
             }>;
-            addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number) => void;
+            addChunkForAfterResuming: (buffer: AudioBuffer, timestamp: number, maxDuration: number | null) => void;
             moveQueuedChunksToPauseQueue: () => void;
             getNumberOfChunksAfterResuming: () => number;
         } | null;
@@ -56,16 +57,17 @@ export declare const drawPreviewOverlay: ({ context, audioTime, audioContextStat
             nonce: import("../nonce-manager").Nonce;
             playbackRate: number;
             getIsPlaying: () => boolean;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
         }) => Promise<void>;
         getAudioIteratorsCreated: () => number;
         setMuted: (newMuted: boolean) => void;
         setVolume: (volume: number) => void;
-        scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, }: {
+        scheduleAudioChunk: ({ buffer, mediaTimestamp, playbackRate, scheduleAudioNode, maxDuration, }: {
             buffer: AudioBuffer;
             mediaTimestamp: number;
             playbackRate: number;
-            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number) => void;
+            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, maxDuration: number | null) => void;
+            maxDuration: number | null;
         }) => void;
     } | null;
     videoIteratorManager: {