@remotion/media 4.0.351

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

@@ -0,0 +1,77 @@
+import { audioManager } from '../caches';
+import { combineAudioDataAndClosePrevious } from '../convert-audiodata/combine-audiodata';
+import { convertAudioData } from '../convert-audiodata/convert-audiodata';
+import { TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from '../convert-audiodata/resample-audiodata';
+import { sinkPromises } from '../video-extraction/extract-frame';
+import { getSinks } from '../video-extraction/get-frames-since-keyframe';
+export const extractAudio = async ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds, volume, logLevel, loop, }) => {
+    if (!sinkPromises[src]) {
+        sinkPromises[src] = getSinks(src);
+    }
+    const { audio, actualMatroskaTimestamps, isMatroska, getDuration } = await sinkPromises[src];
+    if (audio === null) {
+        return null;
+    }
+    const timeInSeconds = loop
+        ? unloopedTimeInSeconds % (await getDuration())
+        : unloopedTimeInSeconds;
+    const sampleIterator = await audioManager.getIterator({
+        src,
+        timeInSeconds,
+        audioSampleSink: audio.sampleSink,
+        isMatroska,
+        actualMatroskaTimestamps,
+    });
+    const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
+    audioManager.logOpenFrames(logLevel);
+    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;
+        // TODO: Apply playback rate
+        // TODO: Apply tone frequency
+        if (isFirstSample) {
+            trimStartInSeconds = timeInSeconds - sample.timestamp;
+        }
+        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,
+            newSampleRate: TARGET_SAMPLE_RATE,
+            trimStartInSeconds,
+            trimEndInSeconds,
+            targetNumberOfChannels: TARGET_NUMBER_OF_CHANNELS,
+            volume,
+        });
+        audioDataRaw.close();
+        if (audioData.numberOfFrames === 0) {
+            continue;
+        }
+        audioDataArray.push(audioData);
+    }
+    if (audioDataArray.length === 0) {
+        return null;
+    }
+    const combined = combineAudioDataAndClosePrevious(audioDataArray);
+    return combined;
+};

package/dist/audio-for-rendering.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import type { AudioProps } from './props';
+export declare const AudioForRendering: React.FC<AudioProps>;

package/dist/audio-for-rendering.js

@@ -0,0 +1,94 @@
+import { useContext, useLayoutEffect, useMemo, useState } from 'react';
+import { cancelRender, Internals, useCurrentFrame, useDelayRender, useRemotionEnvironment, } from 'remotion';
+import { extractFrameViaBroadcastChannel } from './extract-frame-via-broadcast-channel';
+export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted, loopVolumeCurveBehavior, delayRenderRetries, delayRenderTimeoutInMilliseconds, logLevel = window.remotion_logLevel, }) => {
+    const absoluteFrame = Internals.useTimelinePosition();
+    const videoConfig = Internals.useUnsafeVideoConfig();
+    const { registerRenderAsset, unregisterRenderAsset } = useContext(Internals.RenderAssetManager);
+    const frame = useCurrentFrame();
+    const volumePropsFrame = Internals.useFrameForVolumeProp(loopVolumeCurveBehavior ?? 'repeat');
+    const environment = useRemotionEnvironment();
+    const [id] = useState(() => `${Math.random()}`.replace('0.', ''));
+    if (!videoConfig) {
+        throw new Error('No video config found');
+    }
+    if (!src) {
+        throw new TypeError('No `src` was passed to <Video>.');
+    }
+    const volume = Internals.evaluateVolume({
+        volume: volumeProp,
+        frame: volumePropsFrame,
+        mediaVolume: 1,
+    });
+    Internals.warnAboutTooHighVolume(volume);
+    const shouldRenderAudio = useMemo(() => {
+        if (!window.remotion_audioEnabled) {
+            return false;
+        }
+        if (muted) {
+            return false;
+        }
+        if (volume <= 0) {
+            return false;
+        }
+        return true;
+    }, [muted, volume]);
+    const { fps } = videoConfig;
+    const { delayRender, continueRender } = useDelayRender();
+    useLayoutEffect(() => {
+        const actualFps = playbackRate ? fps / playbackRate : fps;
+        const timestamp = frame / actualFps;
+        const durationInSeconds = 1 / actualFps;
+        const newHandle = delayRender(`Extracting frame number ${frame}`, {
+            retries: delayRenderRetries ?? undefined,
+            timeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined,
+        });
+        extractFrameViaBroadcastChannel({
+            src,
+            timeInSeconds: timestamp,
+            durationInSeconds,
+            logLevel: logLevel ?? 'info',
+            shouldRenderAudio,
+            isClientSideRendering: environment.isClientSideRendering,
+        })
+            .then(({ audio }) => {
+            if (audio) {
+                registerRenderAsset({
+                    type: 'inline-audio',
+                    id,
+                    audio: Array.from(audio.data),
+                    sampleRate: audio.sampleRate,
+                    numberOfChannels: audio.numberOfChannels,
+                    frame: absoluteFrame,
+                    timestamp: audio.timestamp,
+                    duration: (audio.numberOfFrames / audio.sampleRate) * 1000000,
+                });
+            }
+            continueRender(newHandle);
+        })
+            .catch((error) => {
+            cancelRender(error);
+        });
+        return () => {
+            continueRender(newHandle);
+            unregisterRenderAsset(id);
+        };
+    }, [
+        absoluteFrame,
+        continueRender,
+        delayRender,
+        delayRenderRetries,
+        delayRenderTimeoutInMilliseconds,
+        environment.isClientSideRendering,
+        fps,
+        frame,
+        id,
+        logLevel,
+        playbackRate,
+        registerRenderAsset,
+        shouldRenderAudio,
+        src,
+        unregisterRenderAsset,
+    ]);
+    return null;
+};

package/dist/audio.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { AudioProps } from './props';
+export declare const Audio: React.FC<AudioProps>;

package/dist/audio.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useContext } from 'react';
+import { cancelRender, Internals, Sequence, useRemotionEnvironment, } from 'remotion';
+import { SharedAudioContext } from '../../core/src/audio/shared-audio-tags';
+import { AudioForRendering } from './audio-for-rendering';
+const { validateMediaTrimProps, resolveTrimProps, validateMediaProps, AudioForPreview, } = Internals;
+export const Audio = (props) => {
+    const audioContext = useContext(SharedAudioContext);
+    // Should only destruct `trimBefore` and `trimAfter` from props,
+    // rest gets drilled down
+    const { trimBefore, trimAfter, name, pauseWhenBuffering, stack, showInTimeline, onError: onRemotionError, loop, ...otherProps } = props;
+    const environment = useRemotionEnvironment();
+    const onDuration = useCallback(() => undefined, []);
+    if (typeof props.src !== 'string') {
+        throw new TypeError(`The \`<Audio>\` tag requires a string for \`src\`, but got ${JSON.stringify(props.src)} instead.`);
+    }
+    validateMediaTrimProps({
+        startFrom: undefined,
+        endAt: undefined,
+        trimBefore,
+        trimAfter,
+    });
+    const { trimBeforeValue, trimAfterValue } = resolveTrimProps({
+        startFrom: undefined,
+        endAt: undefined,
+        trimBefore,
+        trimAfter,
+    });
+    const onError = useCallback((e) => {
+        // eslint-disable-next-line no-console
+        console.log(e.currentTarget.error);
+        // If there is no `loop` property, we don't need to get the duration
+        // and this does not need to be a fatal error
+        const errMessage = `Could not play audio: ${e.currentTarget.error}. See https://remotion.dev/docs/media-playback-error for help.`;
+        if (loop) {
+            if (onRemotionError) {
+                onRemotionError(new Error(errMessage));
+                return;
+            }
+            cancelRender(new Error(errMessage));
+        }
+        else {
+            onRemotionError?.(new Error(errMessage));
+            // eslint-disable-next-line no-console
+            console.warn(errMessage);
+        }
+    }, [onRemotionError, loop]);
+    if (typeof trimBeforeValue !== 'undefined' ||
+        typeof trimAfterValue !== 'undefined') {
+        return (_jsx(Sequence, { layout: "none", from: 0 - (trimBeforeValue ?? 0), showInTimeline: false, durationInFrames: trimAfterValue, name: name, children: _jsx(Audio, { pauseWhenBuffering: pauseWhenBuffering ?? false, ...otherProps }) }));
+    }
+    validateMediaProps(props, 'Video');
+    if (environment.isRendering) {
+        return _jsx(AudioForRendering, { ...otherProps });
+    }
+    const { onAutoPlayError, crossOrigin, delayRenderRetries, delayRenderTimeoutInMilliseconds, ...propsForPreview } = otherProps;
+    return (_jsx(AudioForPreview, { _remotionInternalNativeLoopPassed: props._remotionInternalNativeLoopPassed ?? false, _remotionInternalStack: stack ?? null, shouldPreMountAudioTags: audioContext !== null && audioContext.numberOfAudioTags > 0, ...propsForPreview, onNativeError: onError, onDuration: onDuration, 
+        // Proposal: Make this default to true in v5
+        pauseWhenBuffering: pauseWhenBuffering ?? false, _remotionInternalNeedsDurationCalculation: Boolean(loop), showInTimeline: showInTimeline ?? true }));
+};

package/dist/audiodata-to-array.js

@@ -0,0 +1 @@
+"use strict";

package/dist/caches.d.ts

@@ -0,0 +1,86 @@
+export declare const MAX_CACHE_SIZE: number;
+export declare const SAFE_BACK_WINDOW_IN_SECONDS = 1;
+export declare const keyframeManager: {
+    requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, }: {
+        timestamp: number;
+        packetSink: import("mediabunny").EncodedPacketSink;
+        videoSampleSink: import("mediabunny").VideoSampleSink;
+        src: string;
+        logLevel: import("./log").LogLevel;
+    }) => Promise<import("./video-extraction/keyframe-bank").KeyframeBank>;
+    addKeyframeBank: ({ src, bank, startTimestampInSeconds, }: {
+        src: string;
+        bank: Promise<import("./video-extraction/keyframe-bank").KeyframeBank>;
+        startTimestampInSeconds: number;
+    }) => void;
+    getCacheStats: () => Promise<{
+        count: number;
+        totalSize: number;
+    }>;
+    clearAll: () => Promise<void>;
+};
+export declare const audioManager: {
+    makeIterator: ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+        timeInSeconds: number;
+        src: string;
+        audioSampleSink: import("mediabunny").AudioSampleSink;
+        isMatroska: boolean;
+        actualMatroskaTimestamps: import("./video-extraction/remember-actual-matroska-timestamps").RememberActualMatroskaTimestamps;
+    }) => {
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => Promise<void>;
+        startTimestamp: number;
+    };
+    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+        src: string;
+        timeInSeconds: number;
+        audioSampleSink: import("mediabunny").AudioSampleSink;
+        isMatroska: boolean;
+        actualMatroskaTimestamps: import("./video-extraction/remember-actual-matroska-timestamps").RememberActualMatroskaTimestamps;
+    }) => Promise<{
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => Promise<void>;
+        startTimestamp: number;
+    }>;
+    getCacheStats: () => {
+        count: number;
+        totalSize: number;
+    };
+    getIteratorMostInThePast: () => {
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => Promise<void>;
+        startTimestamp: number;
+    } | null;
+    logOpenFrames: (logLevel: import("./log").LogLevel) => void;
+};
+export declare const getTotalCacheStats: () => Promise<{
+    count: number;
+    totalSize: number;
+}>;

package/dist/caches.js

@@ -0,0 +1,15 @@
+import { makeAudioManager } from './audio-extraction/audio-manager';
+import { makeKeyframeManager } from './video-extraction/keyframe-manager';
+export const MAX_CACHE_SIZE = 1000 * 1000 * 1000; // 1GB
+// 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,
+    };
+};

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

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

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

@@ -0,0 +1,40 @@
+export const combineAudioDataAndClosePrevious = (audioDataArray) => {
+    let numberOfFrames = 0;
+    let numberOfChannels = null;
+    let sampleRate = null;
+    const { timestamp } = audioDataArray[0];
+    for (const audioData of audioDataArray) {
+        numberOfFrames += audioData.numberOfFrames;
+        if (!numberOfChannels) {
+            numberOfChannels = audioData.numberOfChannels;
+        }
+        else if (numberOfChannels !== audioData.numberOfChannels) {
+            throw new Error('Number of channels do not match');
+        }
+        if (!sampleRate) {
+            sampleRate = audioData.sampleRate;
+        }
+        else if (sampleRate !== audioData.sampleRate) {
+            throw new Error('Sample rates do not match');
+        }
+    }
+    if (!numberOfChannels) {
+        throw new Error('Number of channels is not set');
+    }
+    if (!sampleRate) {
+        throw new Error('Sample rate is not set');
+    }
+    const arr = new Int16Array(numberOfFrames * numberOfChannels);
+    let offset = 0;
+    for (const audioData of audioDataArray) {
+        arr.set(audioData.data, offset);
+        offset += audioData.data.length;
+    }
+    return {
+        data: arr,
+        numberOfChannels,
+        numberOfFrames,
+        sampleRate,
+        timestamp,
+    };
+};

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

@@ -0,0 +1,16 @@
+export type ConvertAudioDataOptions = {
+    audioData: AudioData;
+    newSampleRate: number;
+    trimStartInSeconds: number;
+    trimEndInSeconds: number;
+    targetNumberOfChannels: number;
+    volume: number;
+};
+export type PcmS16AudioData = {
+    data: Int16Array;
+    sampleRate: number;
+    numberOfChannels: number;
+    numberOfFrames: number;
+    timestamp: number;
+};
+export declare const convertAudioData: ({ audioData, newSampleRate, trimStartInSeconds, trimEndInSeconds, targetNumberOfChannels, volume, }: ConvertAudioDataOptions) => PcmS16AudioData;

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

@@ -0,0 +1,53 @@
+import { resampleAudioData } from './resample-audiodata';
+const FORMAT = 's16';
+export const convertAudioData = ({ audioData, newSampleRate, trimStartInSeconds, trimEndInSeconds, targetNumberOfChannels, volume, }) => {
+    const { numberOfChannels: srcNumberOfChannels, sampleRate: currentSampleRate, numberOfFrames, } = audioData;
+    const ratio = currentSampleRate / newSampleRate;
+    const frameOffset = Math.round(trimStartInSeconds * audioData.sampleRate);
+    const frameCount = numberOfFrames -
+        Math.round((trimEndInSeconds + trimStartInSeconds) * audioData.sampleRate);
+    const newNumberOfFrames = Math.round(frameCount / ratio);
+    if (newNumberOfFrames === 0) {
+        throw new Error('Cannot resample - the given sample rate would result in less than 1 sample');
+    }
+    if (newSampleRate < 3000 || newSampleRate > 768000) {
+        throw new Error('newSampleRate must be between 3000 and 768000');
+    }
+    const srcChannels = new Int16Array(srcNumberOfChannels * frameCount);
+    audioData.copyTo(srcChannels, {
+        planeIndex: 0,
+        format: FORMAT,
+        frameOffset,
+        frameCount,
+    });
+    const data = new Int16Array(newNumberOfFrames * targetNumberOfChannels);
+    const chunkSize = frameCount / newNumberOfFrames;
+    if (newNumberOfFrames === frameCount &&
+        targetNumberOfChannels === srcNumberOfChannels &&
+        volume === 1) {
+        return {
+            data: srcChannels,
+            numberOfChannels: targetNumberOfChannels,
+            numberOfFrames: newNumberOfFrames,
+            sampleRate: newSampleRate,
+            timestamp: audioData.timestamp + trimStartInSeconds * 1000000,
+        };
+    }
+    resampleAudioData({
+        srcNumberOfChannels,
+        sourceChannels: srcChannels,
+        destination: data,
+        targetFrames: newNumberOfFrames,
+        chunkSize,
+        volume,
+    });
+    const newAudioData = {
+        data,
+        format: FORMAT,
+        numberOfChannels: targetNumberOfChannels,
+        numberOfFrames: newNumberOfFrames,
+        sampleRate: newSampleRate,
+        timestamp: audioData.timestamp + trimStartInSeconds * 1000000,
+    };
+    return newAudioData;
+};

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

@@ -0,0 +1 @@
+export declare const getDataTypeForAudioFormat: (format: AudioSampleFormat) => Float32ArrayConstructor | Int16ArrayConstructor | Uint8ArrayConstructor | Int32ArrayConstructor;

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

@@ -0,0 +1,22 @@
+export const getDataTypeForAudioFormat = (format) => {
+    switch (format) {
+        case 'f32':
+            return Float32Array;
+        case 'f32-planar':
+            return Float32Array;
+        case 's16':
+            return Int16Array;
+        case 's16-planar':
+            return Int16Array;
+        case 'u8':
+            return Uint8Array;
+        case 'u8-planar':
+            return Uint8Array;
+        case 's32':
+            return Int32Array;
+        case 's32-planar':
+            return Int32Array;
+        default:
+            throw new Error(`Unsupported audio format: ${format}`);
+    }
+};

package/dist/convert-audiodata/is-planar-format.d.ts

@@ -0,0 +1 @@
+export declare const isPlanarFormat: (format: AudioSampleFormat) => boolean;

package/dist/convert-audiodata/is-planar-format.js

@@ -0,0 +1,3 @@
+export const isPlanarFormat = (format) => {
+    return format.includes('-planar');
+};

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

@@ -0,0 +1 @@
+export declare const logAudioData: (audioData: AudioData) => string;

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

@@ -0,0 +1,8 @@
+export const logAudioData = (audioData) => {
+    const srcChannels = new Int16Array(audioData.numberOfFrames * audioData.numberOfChannels);
+    audioData.copyTo(srcChannels, {
+        planeIndex: 0,
+        format: 's16',
+    });
+    return srcChannels.slice(0, 10).join(',');
+};

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

@@ -0,0 +1,10 @@
+export declare const TARGET_NUMBER_OF_CHANNELS = 2;
+export declare const TARGET_SAMPLE_RATE = 48000;
+export declare const resampleAudioData: ({ srcNumberOfChannels, sourceChannels, destination, targetFrames, chunkSize, volume, }: {
+    srcNumberOfChannels: number;
+    sourceChannels: Int16Array;
+    destination: Int16Array;
+    targetFrames: number;
+    chunkSize: number;
+    volume: number;
+}) => void;

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

@@ -0,0 +1,72 @@
+// 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;
+export const resampleAudioData = ({ srcNumberOfChannels, sourceChannels, destination, targetFrames, chunkSize, volume, }) => {
+    const getSourceValues = (start, end, channelIndex) => {
+        const sampleCountAvg = end - start;
+        let itemSum = 0;
+        let itemCount = 0;
+        for (let k = 0; k < sampleCountAvg; k++) {
+            const num = sourceChannels[(start + k) * srcNumberOfChannels + channelIndex];
+            itemSum += num;
+            itemCount++;
+        }
+        const average = itemSum / itemCount;
+        const averageVolume = average * volume;
+        if (averageVolume < -32768) {
+            return -32768;
+        }
+        if (averageVolume > 32767) {
+            return 32767;
+        }
+        return averageVolume;
+    };
+    for (let newFrameIndex = 0; newFrameIndex < targetFrames; newFrameIndex++) {
+        const start = Math.floor(newFrameIndex * chunkSize);
+        const end = Math.max(Math.floor(start + chunkSize), start + 1);
+        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 l2 = l + Math.sqrt(1 / 2) * (c + sl);
+            const r2 = r + Math.sqrt(1 / 2) * (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/convert-audiodata/trim-audiodata.js

@@ -0,0 +1 @@
+"use strict";

package/dist/deserialized-audiodata.d.ts

@@ -0,0 +1,15 @@
+import type { DataType } from './convert-audiodata/data-types';
+export type SerializableAudioData = {
+    data: DataType[];
+    format: AudioSampleFormat;
+    numberOfChannels: number;
+    numberOfFrames: number;
+    sampleRate: number;
+};
+export declare const turnAudioDataIntoSerializableData: (audioData: AudioData) => {
+    data: (Float32Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint8Array<ArrayBuffer>)[];
+    format: AudioSampleFormat;
+    numberOfChannels: number;
+    numberOfFrames: number;
+    sampleRate: number;
+};

package/dist/deserialized-audiodata.js

@@ -0,0 +1,26 @@
+import { getDataTypeForAudioFormat } from './convert-audiodata/data-types';
+import { isPlanarFormat } from './convert-audiodata/is-planar-format';
+export const turnAudioDataIntoSerializableData = (audioData) => {
+    if (!audioData.format) {
+        throw new Error('AudioData format is not set');
+    }
+    const DataType = getDataTypeForAudioFormat(audioData.format);
+    const isPlanar = isPlanarFormat(audioData.format);
+    const planes = isPlanar ? audioData.numberOfChannels : 1;
+    const srcChannels = new Array(planes)
+        .fill(true)
+        .map(() => new DataType((isPlanar ? 1 : audioData.numberOfChannels) *
+        audioData.numberOfFrames));
+    for (let i = 0; i < planes; i++) {
+        audioData.copyTo(srcChannels[i], {
+            planeIndex: i,
+        });
+    }
+    return {
+        data: srcChannels,
+        format: audioData.format,
+        numberOfChannels: audioData.numberOfChannels,
+        numberOfFrames: audioData.numberOfFrames,
+        sampleRate: audioData.sampleRate,
+    };
+};