@remotion/media 4.0.430 → 4.0.432

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

@@ -1,113 +0,0 @@
-import { Internals } from 'remotion';
-import { getTotalCacheStats } from '../caches';
-import { makeAudioIterator } from './audio-iterator';
-export const makeAudioManager = () => {
-    const iterators = [];
-    const makeIterator = ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }) => {
-        const iterator = makeAudioIterator({
-            audioSampleSink,
-            isMatroska,
-            startTimestamp: timeInSeconds,
-            src,
-            actualMatroskaTimestamps,
-            logLevel,
-        });
-        iterators.push(iterator);
-        return iterator;
-    };
-    const getIteratorMostInThePast = () => {
-        let mostInThePast = null;
-        let mostInThePastIterator = null;
-        for (const iterator of iterators) {
-            const lastUsed = iterator.getLastUsed();
-            if (mostInThePast === null || lastUsed < mostInThePast) {
-                mostInThePast = lastUsed;
-                mostInThePastIterator = iterator;
-            }
-        }
-        return mostInThePastIterator;
-    };
-    const deleteOldestIterator = () => {
-        const iterator = getIteratorMostInThePast();
-        if (iterator) {
-            iterator.prepareForDeletion();
-            iterators.splice(iterators.indexOf(iterator), 1);
-        }
-    };
-    const deleteDuplicateIterators = (logLevel) => {
-        const seenKeys = new Set();
-        for (let i = 0; i < iterators.length; i++) {
-            const iterator = iterators[i];
-            const key = `${iterator.src}-${iterator.getOldestTimestamp()}-${iterator.getNewestTimestamp()}`;
-            if (seenKeys.has(key)) {
-                iterator.prepareForDeletion();
-                iterators.splice(iterators.indexOf(iterator), 1);
-                Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, `Deleted duplicate iterator for ${iterator.src}`);
-            }
-            seenKeys.add(key);
-        }
-    };
-    const getIterator = async ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }) => {
-        while ((await getTotalCacheStats()).totalSize > maxCacheSize) {
-            deleteOldestIterator();
-        }
-        for (const iterator of iterators) {
-            if (iterator.src === src &&
-                (await iterator.waitForCompletion()) &&
-                iterator.canSatisfyRequestedTime(timeInSeconds)) {
-                return iterator;
-            }
-        }
-        for (let i = 0; i < iterators.length; i++) {
-            const iterator = iterators[i];
-            // delete iterator with same starting timestamp as requested
-            if (iterator.src === src && iterator.startTimestamp === timeInSeconds) {
-                iterator.prepareForDeletion();
-                iterators.splice(iterators.indexOf(iterator), 1);
-            }
-        }
-        deleteDuplicateIterators(logLevel);
-        return makeIterator({
-            src,
-            timeInSeconds,
-            audioSampleSink,
-            isMatroska,
-            actualMatroskaTimestamps,
-            logLevel,
-        });
-    };
-    const getCacheStats = () => {
-        let totalCount = 0;
-        let totalSize = 0;
-        for (const iterator of iterators) {
-            const { count, size } = iterator.getCacheStats();
-            totalCount += count;
-            totalSize += size;
-        }
-        return { count: totalCount, totalSize };
-    };
-    const logOpenFrames = () => {
-        for (const iterator of iterators) {
-            iterator.logOpenFrames();
-        }
-    };
-    let queue = Promise.resolve(undefined);
-    return {
-        getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, maxCacheSize, }) => {
-            queue = queue.then(() => getIterator({
-                src,
-                timeInSeconds,
-                audioSampleSink,
-                isMatroska,
-                actualMatroskaTimestamps,
-                logLevel,
-                maxCacheSize,
-            }));
-            return queue;
-        },
-        getCacheStats,
-        getIteratorMostInThePast,
-        logOpenFrames,
-        deleteDuplicateIterators,
-    };
-};

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

@@ -1,132 +0,0 @@
-import { audioManager } from '../caches';
-import { combineAudioDataAndClosePrevious } from '../convert-audiodata/combine-audiodata';
-import { convertAudioData, fixFloatingPoint, } from '../convert-audiodata/convert-audiodata';
-import { TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from '../convert-audiodata/resample-audiodata';
-import { getSink } from '../get-sink';
-import { getTimeInSeconds } from '../get-time-in-seconds';
-import { isNetworkError, isUnsupportedConfigurationError, } from '../is-type-of-error';
-const extractAudioInternal = async ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds: durationNotYetApplyingPlaybackRate, logLevel, loop, playbackRate, audioStreamIndex, trimBefore, trimAfter, fps, maxCacheSize, }) => {
-    const { getAudio, actualMatroskaTimestamps, isMatroska, getDuration } = await getSink(src, logLevel);
-    let mediaDurationInSeconds = null;
-    if (loop) {
-        mediaDurationInSeconds = await getDuration();
-    }
-    const audio = await getAudio(audioStreamIndex);
-    if (audio === 'network-error') {
-        return 'network-error';
-    }
-    if (audio === 'no-audio-track') {
-        return { data: null, durationInSeconds: null };
-    }
-    if (audio === 'cannot-decode-audio') {
-        return 'cannot-decode';
-    }
-    if (audio === 'unknown-container-format') {
-        return 'unknown-container-format';
-    }
-    const timeInSeconds = getTimeInSeconds({
-        loop,
-        mediaDurationInSeconds,
-        unloopedTimeInSeconds,
-        src,
-        trimAfter,
-        playbackRate,
-        trimBefore,
-        fps,
-        ifNoMediaDuration: 'fail',
-    });
-    if (timeInSeconds === null) {
-        return { data: null, durationInSeconds: mediaDurationInSeconds };
-    }
-    try {
-        const sampleIterator = await audioManager.getIterator({
-            src,
-            timeInSeconds,
-            audioSampleSink: audio.sampleSink,
-            isMatroska,
-            actualMatroskaTimestamps,
-            logLevel,
-            maxCacheSize,
-        });
-        const durationInSeconds = durationNotYetApplyingPlaybackRate * playbackRate;
-        const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
-        audioManager.logOpenFrames();
-        const audioDataArray = [];
-        for (let i = 0; i < samples.length; i++) {
-            const sample = samples[i];
-            // Less than 1 sample would be included - we did not need it after all!
-            if (Math.abs(sample.timestamp - (timeInSeconds + durationInSeconds)) *
-                sample.sampleRate <
-                1) {
-                continue;
-            }
-            // Less than 1 sample would be included - we did not need it after all!
-            if (sample.timestamp + sample.duration <= timeInSeconds) {
-                continue;
-            }
-            const isFirstSample = i === 0;
-            const isLastSample = i === samples.length - 1;
-            const audioDataRaw = sample.toAudioData();
-            // amount of samples to shave from start and end
-            let trimStartInSeconds = 0;
-            let trimEndInSeconds = 0;
-            let leadingSilence = null;
-            if (isFirstSample) {
-                trimStartInSeconds = fixFloatingPoint(timeInSeconds - sample.timestamp);
-                if (trimStartInSeconds < 0) {
-                    const silenceFrames = Math.ceil(fixFloatingPoint(-trimStartInSeconds * TARGET_SAMPLE_RATE));
-                    leadingSilence = {
-                        data: new Int16Array(silenceFrames * TARGET_NUMBER_OF_CHANNELS),
-                        numberOfFrames: silenceFrames,
-                        timestamp: timeInSeconds * 1000000,
-                        durationInMicroSeconds: (silenceFrames / TARGET_SAMPLE_RATE) * 1000000,
-                    };
-                    trimStartInSeconds = 0;
-                }
-            }
-            if (isLastSample) {
-                trimEndInSeconds =
-                    // clamp to 0 in case the audio ends early
-                    Math.max(0, sample.timestamp +
-                        sample.duration -
-                        (timeInSeconds + durationInSeconds));
-            }
-            const audioData = convertAudioData({
-                audioData: audioDataRaw,
-                trimStartInSeconds,
-                trimEndInSeconds,
-                playbackRate,
-                audioDataTimestamp: sample.timestamp,
-                isLast: isLastSample,
-            });
-            audioDataRaw.close();
-            if (audioData.numberOfFrames === 0) {
-                continue;
-            }
-            if (leadingSilence) {
-                audioDataArray.push(leadingSilence);
-            }
-            audioDataArray.push(audioData);
-        }
-        if (audioDataArray.length === 0) {
-            return { data: null, durationInSeconds: mediaDurationInSeconds };
-        }
-        const combined = combineAudioDataAndClosePrevious(audioDataArray);
-        return { data: combined, durationInSeconds: mediaDurationInSeconds };
-    }
-    catch (err) {
-        const error = err;
-        if (isNetworkError(error)) {
-            return 'network-error';
-        }
-        if (isUnsupportedConfigurationError(error)) {
-            return 'cannot-decode';
-        }
-        throw err;
-    }
-};
-let queue = Promise.resolve(undefined);
-export const extractAudio = (params) => {
-    queue = queue.then(() => extractAudioInternal(params));
-    return queue;
-};

package/dist/audio-iterator-manager.js

@@ -1,228 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

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

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

@@ -1,17 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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;
-};