Out-of-context audio tools MVP

[itsramiel]

General Idea

We want to provide api for for triming, generating static waveform, [insert your ideas here] AudioBuffers as well as longer files (that shouldn't be really loaded into memory), that can be done outside of the AudioContext and realtime aspect of it.

It should be designed while taking the Encoder/Decoder and other out-of-audio-context issues into consideration (as parts of the implementation will be shared or at least similar)

Example TS API

// Example usage 1
const file = await openAudioFile(path: string);
const outputFile1 = await trimAudioFile(file, 0.35, file.duration - 0.35); // durations in seconds
const outputFile2 = await trimAudioFile(file, 128, file.durationSR - 128); // durations in sample rate(?)

// reuses same codec/format as original
await writeAudioFile(outputFile1, `${Directory.Document}/myfiles/output1.mp3`);

// encode with different format
await writeAudioFile(outputFile2, Encoders.M4A.High, `${Directory.Document}/myfiles/output2.m4a`);

// Example usage 2
await openAudioFile(path: string)
  .trim((info) => ({ start: 0.35, end: info.duration - 0.35 }))
  .saveAs(`${Directory.Document}/myfiles/output.mp3`)

Note: this TS examples are not well-thought and might be unrealistic, make sure the api will better align with encoders, decoders and other tooling before starting any implementation!

TheMostImportantNode: This issue is potentially huge it should be split into smaller ones once we decide on the approach

The purpouse of the task is to provide design document that will be used as a base for further development

[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);
            }
        }
    }
};