Support trim audio file operation

[itsramiel]

Feature Request

Hi,

I am interested in being able to create a new trimmed audio file from a source audio file.

I created a discussion whether this is something this library would be interested in supporting, and it seems to be.

Looking forward to this being implemented!
Feel free to close if this is no longer something this lib want to support

[Energieman]

I got this working using 'AudioContext', it trims fine but for shorter lengths audios (and videos sounds - yep). Sadly it Fails and crash build for longer length

export const trimAudio = async (audioFile, startTime = null, endTime = null) => {
    let audioContext = null;
    try {
        // Create a new AudioContext
        audioContext = new AudioContext();
        if (!audioContext) {
            throw new Error('Failed to create AudioContext');
        }

        // Fetch and decode the audio file first to get duration
        const response = await fetch(audioFile);
        const arrayBuffer = await response.arrayBuffer();
        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);

        // Calculate full audio duration
        const fullDuration = audioBuffer.duration;
        const sampleRate = audioBuffer.sampleRate;

        // Determine startSeconds: use provided startTime or default to 0
        let startSeconds;
        if (startTime === null || startTime === undefined) {
            startSeconds = 0; // Trim from beginning of audio
        } else {
            startSeconds = typeof startTime === 'string' ? timeStringToSeconds(startTime) : startTime;
        }

        // Determine endSeconds: use provided endTime or full duration
        let endSeconds;
        if (endTime === null || endTime === undefined) {
            endSeconds = fullDuration; // Trim to end of audio
        } else {
            endSeconds = typeof endTime === 'string' ? timeStringToSeconds(endTime) : endTime;
        }

        // Validate inputs
        if (startSeconds < 0 || endSeconds <= startSeconds) {
            throw new Error('Invalid trim times: start time must be less than end time and non-negative');
        }
        if (startSeconds > fullDuration) {
            throw new Error('Start time exceeds audio duration');
        }
        if (endSeconds > fullDuration) {
            throw new Error('End time exceeds audio duration');
        }

        // Calculate the trim points in samples
        const startSample = Math.floor(startSeconds * sampleRate);
        const endSample = Math.floor(endSeconds * sampleRate);
        const durationSamples = endSample - startSample;

        // Create a new audio buffer for the trimmed audio
        const trimmedBuffer = audioContext.createBuffer(
            audioBuffer.numberOfChannels,
            durationSamples,
            sampleRate
        );

        // Copy the trimmed portion to the new buffer
        for (let channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
            const inputData = audioBuffer.getChannelData(channel);
            const outputData = trimmedBuffer.getChannelData(channel);
            outputData.set(inputData.subarray(startSample, endSample));
        }

        // Return the trimmed audio buffer
        return trimmedBuffer;

    } catch (error) {
        console.error('Error trimming audio:', error);
        throw error;
    } finally {
        // Only attempt to close AudioContext if it exists and supports close
        if (audioContext && typeof audioContext.close === 'function') {
            try {
                await audioContext.close();
            } catch (closeError) {
                console.warn('Failed to close AudioContext:', closeError);
            }
        }
    }
};