@siteed/audio-studio 3.0.2 → 3.0.4

package/src/trimAudio.ts

@@ -1,16 +1,65 @@
 import { LegacyEventEmitter, type EventSubscription } from 'expo-modules-core'
 
 import {
+    BitDepth,
     TrimAudioOptions,
     TrimAudioResult,
     TrimProgressEvent,
 } from './AudioStudio.types'
 import AudioStudioModule from './AudioStudioModule'
+import { isWeb } from './constants'
+import { processAudioBuffer } from './utils/audioProcessing'
 import { cleanNativeOptions } from './utils/cleanNativeOptions'
+import { encodeCompressedAudio } from './utils/encodeCompressedAudio.web'
+import { resampleAudioBuffer } from './utils/resampleAudioBuffer.web'
+import { writeWavHeader } from './utils/writeWavHeader'
 
 // Create a single emitter instance
 const emitter = new LegacyEventEmitter(AudioStudioModule)
 
+function sliceAudioBuffer(
+    src: AudioBuffer,
+    ctx: AudioContext,
+    startMs: number,
+    endMs: number
+): AudioBuffer {
+    const sr = src.sampleRate
+    const start = Math.floor((startMs / 1000) * sr)
+    const end = Math.min(Math.ceil((endMs / 1000) * sr), src.length)
+    const length = Math.max(0, end - start)
+    const out = ctx.createBuffer(src.numberOfChannels, length, sr)
+    for (let c = 0; c < src.numberOfChannels; c++) {
+        out.getChannelData(c).set(src.getChannelData(c).subarray(start, end))
+    }
+    return out
+}
+
+function encodeBufferToWav(
+    buffer: AudioBuffer,
+    bitDepth: BitDepth
+): ArrayBuffer {
+    const { length, numberOfChannels, sampleRate } = buffer
+    const channels: Float32Array[] = []
+    for (let c = 0; c < numberOfChannels; c++) {
+        channels.push(buffer.getChannelData(c))
+    }
+    const interleavedData = new Int16Array(length * numberOfChannels)
+    for (let i = 0; i < length; i++) {
+        for (let c = 0; c < numberOfChannels; c++) {
+            const clamped = Math.max(-1, Math.min(1, channels[c][i]))
+            interleavedData[i * numberOfChannels + c] = Math.round(
+                clamped * 32767
+            )
+        }
+    }
+    return writeWavHeader({
+        buffer: interleavedData.buffer as ArrayBuffer,
+        sampleRate,
+        numChannels: numberOfChannels,
+        bitDepth,
+    })
+}
+
 /**
  * Trims an audio file based on the provided options.
  *
@@ -52,6 +101,308 @@ export async function trimAudio(
         )
     }
 
+    if (isWeb) {
+        try {
+            const startTime = performance.now()
+            const {
+                fileUri,
+                startTimeMs,
+                endTimeMs,
+                ranges,
+                outputFileName,
+                outputFormat,
+            } = options
+
+            // Create AudioContext
+            const audioContext = new (window.AudioContext ||
+                (window as any).webkitAudioContext)()
+
+            // First, load the entire audio file to get its properties
+            const response = await fetch(fileUri)
+            const arrayBuffer = await response.arrayBuffer()
+            const originalAudioBuffer =
+                await audioContext.decodeAudioData(arrayBuffer)
+
+            // Get original audio properties
+            const originalSampleRate = originalAudioBuffer.sampleRate
+            const originalChannels = originalAudioBuffer.numberOfChannels
+
+            // Determine output format - use original values as defaults if not specified
+            let format = outputFormat?.format || 'wav'
+            const targetSampleRate =
+                outputFormat?.sampleRate || originalSampleRate
+            const targetChannels = outputFormat?.channels || originalChannels
+            const targetBitDepth = outputFormat?.bitDepth || 16
+
+            // Get file info from the URL
+            const filename =
+                outputFileName ||
+                fileUri.split('/').pop() ||
+                'trimmed-audio.wav'
+
+            // Process based on mode
+            let resultBuffer: AudioBuffer
+
+            // Report initial progress
+            progressCallback?.({ progress: 10 })
+
+            if (mode === 'single') {
+                // Single mode: extract a single range
+                // Use original sample rate and channels for extraction to preserve quality
+                const { buffer } = await processAudioBuffer({
+                    fileUri,
+                    targetSampleRate, // Use the requested sample rate
+                    targetChannels,
+                    normalizeAudio: false,
+                    startTimeMs,
+                    endTimeMs,
+                    audioContext,
+                })
+
+                resultBuffer = buffer
+
+                // If we need to change sample rate or channels, do it after extraction
+                if (
+                    targetSampleRate !== originalSampleRate ||
+                    targetChannels !== originalChannels
+                ) {
+                    resultBuffer = await resampleAudioBuffer(
+                        buffer,
+                        targetSampleRate,
+                        targetChannels
+                    )
+                }
+            } else {
+                // For keep or remove modes
+                const fullDuration = originalAudioBuffer.duration * 1000 // in ms
+
+                type ProcessSegment = {
+                    startTimeMs: number
+                    endTimeMs: number
+                }
+
+                let segmentsToProcess: ProcessSegment[] = []
+
+                if (mode === 'keep') {
+                    // For keep mode, use the ranges directly
+                    segmentsToProcess = ranges!
+                } else {
+                    // mode === 'remove'
+                    // For remove mode, invert the ranges
+                    const sortedRanges = [...ranges!].sort(
+                        (a, b) => a.startTimeMs - b.startTimeMs
+                    )
+
+                    // Add segment from start to first range if needed
+                    if (
+                        sortedRanges.length > 0 &&
+                        sortedRanges[0].startTimeMs > 0
+                    ) {
+                        segmentsToProcess.push({
+                            startTimeMs: 0,
+                            endTimeMs: sortedRanges[0].startTimeMs,
+                        })
+                    }
+
+                    // Add segments between ranges
+                    for (let i = 0; i < sortedRanges.length - 1; i++) {
+                        segmentsToProcess.push({
+                            startTimeMs: sortedRanges[i].endTimeMs,
+                            endTimeMs: sortedRanges[i + 1].startTimeMs,
+                        })
+                    }
+
+                    // Add segment from last range to end if needed
+                    if (
+                        sortedRanges.length > 0 &&
+                        sortedRanges[sortedRanges.length - 1].endTimeMs <
+                            fullDuration
+                    ) {
+                        segmentsToProcess.push({
+                            startTimeMs:
+                                sortedRanges[sortedRanges.length - 1].endTimeMs,
+                            endTimeMs: fullDuration,
+                        })
+                    }
+                }
+
+                // Filter out empty or invalid segments
+                segmentsToProcess = segmentsToProcess.filter(
+                    (segment) =>
+                        segment.startTimeMs < segment.endTimeMs &&
+                        segment.endTimeMs - segment.startTimeMs > 1
+                ) // 1ms minimum
+
+                if (segmentsToProcess.length === 0) {
+                    throw new Error(
+                        'No valid segments to process after filtering ranges'
+                    )
+                }
+
+                // Process each segment using original sample rate and channels
+                const segmentBuffers: AudioBuffer[] = []
+
+                for (let i = 0; i < segmentsToProcess.length; i++) {
+                    const segment = segmentsToProcess[i]
+
+                    // Report progress for each segment
+                    progressCallback?.({
+                        progress:
+                            10 +
+                            Math.round((i / segmentsToProcess.length) * 40),
+                    })
+
+                    // Slice from the already-decoded buffer (avoids N re-fetches)
+                    const segmentBuffer = sliceAudioBuffer(
+                        originalAudioBuffer,
+                        audioContext,
+                        segment.startTimeMs,
+                        segment.endTimeMs
+                    )
+
+                    segmentBuffers.push(segmentBuffer)
+                }
+
+                // Concatenate all segments
+                const totalSamples = segmentBuffers.reduce(
+                    (sum, buffer) => sum + buffer.length,
+                    0
+                )
+
+                // Create buffer with original properties first
+                const concatenatedBuffer = audioContext.createBuffer(
+                    originalChannels,
+                    totalSamples,
+                    originalSampleRate
+                )
+
+                let offset = 0
+                for (const segmentBuffer of segmentBuffers) {
+                    for (
+                        let channel = 0;
+                        channel < originalChannels;
+                        channel++
+                    ) {
+                        const outputData =
+                            concatenatedBuffer.getChannelData(channel)
+                        const segmentData =
+                            segmentBuffer.getChannelData(channel)
+
+                        for (let i = 0; i < segmentBuffer.length; i++) {
+                            outputData[offset + i] = segmentData[i]
+                        }
+                    }
+                    offset += segmentBuffer.length
+                }
+
+                resultBuffer = concatenatedBuffer
+
+                // If we need to change sample rate or channels, do it after concatenation
+                if (
+                    targetSampleRate !== originalSampleRate ||
+                    targetChannels !== originalChannels
+                ) {
+                    resultBuffer = await resampleAudioBuffer(
+                        concatenatedBuffer,
+                        targetSampleRate,
+                        targetChannels
+                    )
+                }
+            }
+
+            // Report progress (50% - processing complete)
+            progressCallback?.({ progress: 50 })
+
+            // Encode the result based on the requested format
+            let outputData: ArrayBuffer
+            let outputMimeType: string
+            let compressionInfo: TrimAudioResult['compression'] = undefined
+
+            // AAC is not reliably supported in browsers; fall back to opus
+            if (format === 'aac') {
+                console.warn(
+                    'AAC format is not supported on web platforms. Falling back to OPUS format.'
+                )
+                format = 'opus'
+            }
+
+            if (format === 'wav') {
+                outputData = encodeBufferToWav(
+                    resultBuffer,
+                    targetBitDepth as BitDepth
+                )
+                outputMimeType = 'audio/wav'
+            } else if (format === 'opus') {
+                try {
+                    const { data, bitrate } = await encodeCompressedAudio(
+                        resultBuffer,
+                        format,
+                        outputFormat?.bitrate
+                    )
+                    outputData = data
+                    outputMimeType = 'audio/webm'
+                    compressionInfo = { format, bitrate, size: data.byteLength }
+                } catch (error) {
+                    console.warn(
+                        `Failed to encode to ${format}, falling back to WAV: ${error}`
+                    )
+                    outputData = encodeBufferToWav(
+                        resultBuffer,
+                        targetBitDepth as BitDepth
+                    )
+                    outputMimeType = 'audio/wav'
+                }
+            } else {
+                // Default to WAV for unsupported formats
+                console.warn(
+                    `Format ${format} not supported on web, using WAV instead`
+                )
+                outputData = encodeBufferToWav(
+                    resultBuffer,
+                    targetBitDepth as BitDepth
+                )
+                outputMimeType = 'audio/wav'
+            }
+
+            // Report progress (90% - encoding complete)
+            progressCallback?.({ progress: 90 })
+
+            // Create a blob and URL for the result
+            const blob = new Blob([outputData], { type: outputMimeType })
+            const outputUri = URL.createObjectURL(blob)
+
+            // Calculate processing time
+            const processingTimeMs = performance.now() - startTime
+
+            // Report progress (100% - complete)
+            progressCallback?.({ progress: 100 })
+
+            // Create result object
+            const result: TrimAudioResult = {
+                uri: outputUri,
+                filename,
+                durationMs: Math.round(resultBuffer.duration * 1000),
+                size: outputData.byteLength,
+                sampleRate: resultBuffer.sampleRate,
+                channels: resultBuffer.numberOfChannels,
+                bitDepth: targetBitDepth,
+                mimeType: outputMimeType,
+                processingInfo: {
+                    durationMs: processingTimeMs,
+                },
+            }
+
+            if (compressionInfo) {
+                result.compression = compressionInfo
+            }
+
+            return result
+        } catch (error) {
+            console.error('Error in trimAudio:', error)
+            throw error
+        }
+    }
+
     // Set up progress event listener if callback is provided
     let subscription: EventSubscription | undefined
     if (progressCallback) {

package/src/utils/encodeCompressedAudio.web.ts

@@ -0,0 +1,78 @@
+/**
+ * NOTE: Encodes audio in real-time via AudioContext + MediaRecorder playback.
+ * A 60-second clip takes ~60 seconds to encode — this is a known Web Audio API
+ * limitation; there is no offline API for Opus/AAC encoding in browsers.
+ */
+export function encodeCompressedAudio(
+    buffer: AudioBuffer,
+    format: 'opus' | 'aac',
+    bitrate?: number
+): Promise<{ data: ArrayBuffer; bitrate: number }> {
+    return new Promise((resolve, reject) => {
+        try {
+            // On web, always use opus if aac is requested (browser aac support is rare)
+            const actualFormat = format === 'aac' ? 'opus' : format
+
+            // Check if MediaRecorder supports the requested format
+            const mimeType =
+                actualFormat === 'opus' ? 'audio/webm;codecs=opus' : 'audio/aac'
+            if (!MediaRecorder.isTypeSupported(mimeType)) {
+                throw new Error(`MediaRecorder does not support ${mimeType}`)
+            }
+
+            // Create a new AudioContext and source
+            const ctx = new (window.AudioContext ||
+                (window as any).webkitAudioContext)()
+            const source = ctx.createBufferSource()
+            source.buffer = buffer
+
+            // Create a MediaStreamDestination to capture the audio
+            const destination = ctx.createMediaStreamDestination()
+            source.connect(destination)
+
+            // Create a MediaRecorder with the requested format
+            const recorder = new MediaRecorder(destination.stream, {
+                mimeType,
+                audioBitsPerSecond:
+                    bitrate || (actualFormat === 'opus' ? 32000 : 64000),
+            })
+
+            const chunks: Blob[] = []
+
+            recorder.ondataavailable = (e) => {
+                if (e.data.size > 0) {
+                    chunks.push(e.data)
+                }
+            }
+
+            recorder.onstop = async () => {
+                try {
+                    const blob = new Blob(chunks, { type: mimeType })
+                    const arrayBuffer = await blob.arrayBuffer()
+
+                    // Get the actual bitrate used
+                    const actualBitrate = Math.round(
+                        (arrayBuffer.byteLength * 8) / buffer.duration
+                    )
+
+                    resolve({
+                        data: arrayBuffer,
+                        bitrate: actualBitrate / 1000, // Convert to kbps
+                    })
+
+                    // Clean up
+                    ctx.close()
+                } catch (error) {
+                    reject(error)
+                }
+            }
+
+            // Start recording and playback; stop recorder when playback ends
+            recorder.start()
+            source.onended = () => recorder.stop()
+            source.start(0)
+        } catch (error) {
+            reject(error)
+        }
+    })
+}

package/src/utils/resampleAudioBuffer.web.ts

@@ -0,0 +1,39 @@
+export async function resampleAudioBuffer(
+    buffer: AudioBuffer,
+    targetSampleRate: number,
+    targetChannels: number
+): Promise<AudioBuffer> {
+    // If no change needed, return the original buffer
+    if (
+        buffer.sampleRate === targetSampleRate &&
+        buffer.numberOfChannels === targetChannels
+    ) {
+        return buffer
+    }
+
+    // Calculate the new length based on the sample rate change
+    const newLength = Math.round(
+        (buffer.length * targetSampleRate) / buffer.sampleRate
+    )
+
+    // Create an offline context for resampling
+    const offlineContext = new OfflineAudioContext(
+        targetChannels,
+        newLength,
+        targetSampleRate
+    )
+
+    // Create a source node
+    const source = offlineContext.createBufferSource()
+    source.buffer = buffer
+
+    // The OfflineAudioContext was created with targetChannels; the Web Audio API
+    // applies its built-in speaker downmix/upmix rules automatically.
+    source.connect(offlineContext.destination)
+
+    // Start rendering
+    source.start(0)
+    const resampledBuffer = await offlineContext.startRendering()
+
+    return resampledBuffer
+}

package/build/cjs/AudioAnalysis/extractWaveform.js

@@ -1,18 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractWaveform = void 0;
-const AudioStudioModule_1 = __importDefault(require("../AudioStudioModule"));
-const extractWaveform = async ({ fileUri, numberOfSamples, offset = 0, length, }) => {
-    const res = await AudioStudioModule_1.default.extractAudioAnalysis({
-        fileUri,
-        numberOfSamples,
-        offset,
-        length,
-    });
-    return res;
-};
-exports.extractWaveform = extractWaveform;
-//# sourceMappingURL=extractWaveform.js.map

package/build/cjs/AudioAnalysis/extractWaveform.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extractWaveform.js","sourceRoot":"","sources":["../../../src/AudioAnalysis/extractWaveform.ts"],"names":[],"mappings":";;;;;;AAAA,6EAAoD;AAQ7C,MAAM,eAAe,GAAG,KAAK,EAAE,EAClC,OAAO,EACP,eAAe,EACf,MAAM,GAAG,CAAC,EACV,MAAM,GACa,EAAoB,EAAE;IACzC,MAAM,GAAG,GAAG,MAAM,2BAAiB,CAAC,oBAAoB,CAAC;QACrD,OAAO;QACP,eAAe;QACf,MAAM;QACN,MAAM;KACT,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACd,CAAC,CAAA;AAbY,QAAA,eAAe,mBAa3B","sourcesContent":["import AudioStudioModule from '../AudioStudioModule'\n\nexport interface ExtractWaveformProps {\n    fileUri: string\n    numberOfSamples: number\n    offset?: number\n    length?: number\n}\nexport const extractWaveform = async ({\n    fileUri,\n    numberOfSamples,\n    offset = 0,\n    length,\n}: ExtractWaveformProps): Promise<unknown> => {\n    const res = await AudioStudioModule.extractAudioAnalysis({\n        fileUri,\n        numberOfSamples,\n        offset,\n        length,\n    })\n    return res\n}\n"]}

package/build/esm/AudioAnalysis/extractWaveform.js

@@ -1,11 +0,0 @@
-import AudioStudioModule from '../AudioStudioModule';
-export const extractWaveform = async ({ fileUri, numberOfSamples, offset = 0, length, }) => {
-    const res = await AudioStudioModule.extractAudioAnalysis({
-        fileUri,
-        numberOfSamples,
-        offset,
-        length,
-    });
-    return res;
-};
-//# sourceMappingURL=extractWaveform.js.map

package/build/esm/AudioAnalysis/extractWaveform.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extractWaveform.js","sourceRoot":"","sources":["../../../src/AudioAnalysis/extractWaveform.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,sBAAsB,CAAA;AAQpD,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,EAAE,EAClC,OAAO,EACP,eAAe,EACf,MAAM,GAAG,CAAC,EACV,MAAM,GACa,EAAoB,EAAE;IACzC,MAAM,GAAG,GAAG,MAAM,iBAAiB,CAAC,oBAAoB,CAAC;QACrD,OAAO;QACP,eAAe;QACf,MAAM;QACN,MAAM;KACT,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACd,CAAC,CAAA","sourcesContent":["import AudioStudioModule from '../AudioStudioModule'\n\nexport interface ExtractWaveformProps {\n    fileUri: string\n    numberOfSamples: number\n    offset?: number\n    length?: number\n}\nexport const extractWaveform = async ({\n    fileUri,\n    numberOfSamples,\n    offset = 0,\n    length,\n}: ExtractWaveformProps): Promise<unknown> => {\n    const res = await AudioStudioModule.extractAudioAnalysis({\n        fileUri,\n        numberOfSamples,\n        offset,\n        length,\n    })\n    return res\n}\n"]}

package/build/types/AudioAnalysis/extractWaveform.d.ts

@@ -1,8 +0,0 @@
-export interface ExtractWaveformProps {
-    fileUri: string;
-    numberOfSamples: number;
-    offset?: number;
-    length?: number;
-}
-export declare const extractWaveform: ({ fileUri, numberOfSamples, offset, length, }: ExtractWaveformProps) => Promise<unknown>;
-//# sourceMappingURL=extractWaveform.d.ts.map

package/build/types/AudioAnalysis/extractWaveform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extractWaveform.d.ts","sourceRoot":"","sources":["../../../src/AudioAnalysis/extractWaveform.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAClB;AACD,eAAO,MAAM,eAAe,GAAU,+CAKnC,oBAAoB,KAAG,OAAO,CAAC,OAAO,CAQxC,CAAA"}

package/src/AudioAnalysis/extractWaveform.ts

@@ -1,22 +0,0 @@
-import AudioStudioModule from '../AudioStudioModule'
-
-export interface ExtractWaveformProps {
-    fileUri: string
-    numberOfSamples: number
-    offset?: number
-    length?: number
-}
-export const extractWaveform = async ({
-    fileUri,
-    numberOfSamples,
-    offset = 0,
-    length,
-}: ExtractWaveformProps): Promise<unknown> => {
-    const res = await AudioStudioModule.extractAudioAnalysis({
-        fileUri,
-        numberOfSamples,
-        offset,
-        length,
-    })
-    return res
-}