@siteed/audio-studio 3.0.2 → 3.0.3

package/src/AudioAnalysis/extractAudioData.ts

@@ -1,13 +1,195 @@
-import { ExtractAudioDataOptions } from '../AudioStudio.types'
+import {
+    BitDepth,
+    ExtractAudioDataOptions,
+    ExtractedAudioData,
+} from '../AudioStudio.types'
 import AudioStudioModule from '../AudioStudioModule'
 import { isWeb } from '../constants'
+import { processAudioBuffer } from '../utils/audioProcessing'
 import { cleanNativeOptions } from '../utils/cleanNativeOptions'
+import crc32 from '../utils/crc32'
+import { writeWavHeader } from '../utils/writeWavHeader'
 
-export const extractAudioData = async (props: ExtractAudioDataOptions) => {
+export const extractAudioData = async (
+    props: ExtractAudioDataOptions
+): Promise<ExtractedAudioData> => {
     if (isWeb) {
-        // Web implementation handles logger natively in AudioStudioModule.ts
-        return await AudioStudioModule.extractAudioData(props)
+        try {
+            const {
+                fileUri,
+                position,
+                length,
+                startTimeMs,
+                endTimeMs,
+                decodingOptions,
+                includeNormalizedData,
+                includeBase64Data,
+                includeWavHeader = false,
+                logger,
+            } = props
+
+            logger?.debug('EXTRACT AUDIO - Step 1: Initial request', {
+                fileUri,
+                extractionParams: {
+                    position,
+                    length,
+                    startTimeMs,
+                    endTimeMs,
+                },
+                decodingOptions: {
+                    targetSampleRate:
+                        decodingOptions?.targetSampleRate ?? 16000,
+                    targetChannels: decodingOptions?.targetChannels ?? 1,
+                    targetBitDepth: decodingOptions?.targetBitDepth ?? 16,
+                    normalizeAudio: decodingOptions?.normalizeAudio ?? false,
+                },
+                outputOptions: {
+                    includeNormalizedData,
+                    includeBase64Data,
+                    includeWavHeader,
+                },
+            })
+
+            // Process the audio using shared helper function
+            const processedBuffer = await processAudioBuffer({
+                fileUri,
+                targetSampleRate: decodingOptions?.targetSampleRate ?? 16000,
+                targetChannels: decodingOptions?.targetChannels ?? 1,
+                normalizeAudio: decodingOptions?.normalizeAudio ?? false,
+                position,
+                length,
+                startTimeMs,
+                endTimeMs,
+                logger,
+            })
+
+            logger?.debug('EXTRACT AUDIO - Step 2: Audio processing complete', {
+                processedData: {
+                    samples: processedBuffer.samples,
+                    sampleRate: processedBuffer.sampleRate,
+                    channels: processedBuffer.channels,
+                    durationMs: processedBuffer.durationMs,
+                },
+            })
+
+            const channelData = processedBuffer.channelData
+            const bitDepth = (decodingOptions?.targetBitDepth ?? 16) as BitDepth
+            const bytesPerSample = bitDepth / 8
+            const numSamples = processedBuffer.samples
+
+            logger?.debug('EXTRACT AUDIO - Step 3: PCM conversion setup', {
+                channelData: {
+                    length: channelData.length,
+                    first: channelData[0],
+                    last: channelData[channelData.length - 1],
+                },
+                calculation: {
+                    bitDepth,
+                    bytesPerSample,
+                    numSamples,
+                    expectedBytes: numSamples * bytesPerSample,
+                },
+            })
+
+            // Create PCM data with correct length based on original byte length
+            const pcmData = new Uint8Array(numSamples * bytesPerSample)
+            let offset = 0
+
+            // Convert Float32 samples to PCM format
+            for (let i = 0; i < numSamples; i++) {
+                const sample = channelData[i]
+                const value = Math.max(-1, Math.min(1, sample))
+                // Convert to 16-bit signed integer
+                let intValue = Math.round(value * 32767)
+
+                // Handle negative values correctly
+                if (intValue < 0) {
+                    intValue = 65536 + intValue
+                }
+
+                // Write as little-endian
+                pcmData[offset++] = intValue & 255 // Low byte
+                pcmData[offset++] = (intValue >> 8) & 255 // High byte
+            }
+
+            const durationMs = Math.round(
+                (numSamples / processedBuffer.sampleRate) * 1000
+            )
+
+            logger?.debug('EXTRACT AUDIO - Step 4: Final output', {
+                pcmData: {
+                    length: pcmData.length,
+                    first: pcmData[0],
+                    last: pcmData[pcmData.length - 1],
+                },
+                timing: {
+                    numSamples,
+                    sampleRate: processedBuffer.sampleRate,
+                    durationMs,
+                    shouldBe3000ms: endTimeMs
+                        ? endTimeMs - (startTimeMs ?? 0) === 3000
+                        : undefined,
+                },
+            })
+
+            const result: ExtractedAudioData = {
+                pcmData: new Uint8Array(pcmData.buffer),
+                sampleRate: processedBuffer.sampleRate,
+                channels: processedBuffer.channels,
+                bitDepth,
+                durationMs,
+                format: `pcm_${bitDepth}bit` as const,
+                samples: numSamples,
+            }
+
+            // Add WAV header if requested
+            if (includeWavHeader) {
+                logger?.debug('EXTRACT AUDIO - Step 5: Adding WAV header', {
+                    originalLength: pcmData.length,
+                    newLength: result.pcmData.length,
+                    firstBytes: Array.from(result.pcmData.slice(0, 44)), // WAV header is 44 bytes
+                })
+                const wavBuffer = writeWavHeader({
+                    buffer: pcmData.buffer.slice(0, pcmData.length),
+                    sampleRate: processedBuffer.sampleRate,
+                    numChannels: processedBuffer.channels,
+                    bitDepth,
+                })
+                result.pcmData = new Uint8Array(wavBuffer)
+                result.hasWavHeader = true
+            }
+
+            if (includeNormalizedData) {
+                result.normalizedData = channelData
+            }
+
+            if (includeBase64Data) {
+                result.base64Data = btoa(
+                    String.fromCharCode(...new Uint8Array(pcmData.buffer))
+                )
+            }
+
+            if (props.computeChecksum) {
+                result.checksum = crc32.buf(pcmData)
+            }
+
+            logger?.debug('EXTRACT AUDIO - Step 3: PCM conversion complete', {
+                pcmStats: {
+                    length: pcmData.length,
+                    bytesPerSample,
+                    totalSamples: numSamples,
+                    firstBytes: Array.from(pcmData.slice(0, 16)),
+                    lastBytes: Array.from(pcmData.slice(-16)),
+                },
+            })
+
+            return result
+        } catch (error) {
+            props.logger?.error('EXTRACT AUDIO - Error:', error)
+            throw error
+        }
     }
+
     // Native: only pass serializable fields — logger causes crash on Android
     const { logger: _logger, ...nativeOptions } = props
     // Clean undefined values to avoid Android Kotlin bridge crash

package/src/AudioAnalysis/melSpectrogramWasm.web.ts

@@ -1,29 +1,5 @@
 import type { MelSpectrogramWasmModule } from './mel-spectrogram-wasm'
-import { getMelSpectrogramWasmUrl, _registerModuleReset } from './wasmConfig'
-
-let modulePromise: Promise<MelSpectrogramWasmModule> | null = null
-
-_registerModuleReset(() => {
-    modulePromise = null
-})
-
-function getModule(): Promise<MelSpectrogramWasmModule> {
-    if (!modulePromise) {
-        modulePromise = (async () => {
-            const url = getMelSpectrogramWasmUrl()
-            // webpackIgnore + @vite-ignore prevent bundlers from trying to resolve the URL
-            const mod = await import(
-                /* webpackIgnore: true */ /* @vite-ignore */ url
-            )
-            const factory = mod.default ?? mod
-            return factory() as Promise<MelSpectrogramWasmModule>
-        })().catch((err) => {
-            modulePromise = null
-            throw err
-        })
-    }
-    return modulePromise
-}
+import { getWasmModule } from './wasmLoader.web'
 
 // --- Streaming (per-frame) API for live mel spectrogram ---
 
@@ -46,7 +22,7 @@ export async function initMelStreamingWasm(
     fMin = 0,
     fMax = 0
 ): Promise<void> {
-    const Module = await getModule()
+    const Module = (await getWasmModule()) as MelSpectrogramWasmModule
     streamingModule = Module
     const actualFMax = fMax > 0 ? fMax : sampleRate / 2
     Module._mel_spectrogram_init(
@@ -61,6 +37,13 @@ export async function initMelStreamingWasm(
     )
     streamingNMels = nMels
 
+    // Free frame buffer from previous session (if any) to avoid leak on re-init
+    if (streamingFramePtr) {
+        Module._free(streamingFramePtr)
+        streamingFramePtr = 0
+        streamingFrameCapacity = 0
+    }
+
     // Pre-allocate output buffer (fixed size)
     if (streamingMelPtr) Module._free(streamingMelPtr)
     streamingMelPtr = Module._malloc(nMels * 4)
@@ -120,7 +103,7 @@ export async function computeMelSpectrogramWasm(
     normalize: boolean,
     logScale: boolean
 ): Promise<number[][]> {
-    const Module = await getModule()
+    const Module = (await getWasmModule()) as MelSpectrogramWasmModule
 
     const fftLength = 2048
     const windowTypeInt = windowType === 'hamming' ? 1 : 0

package/src/AudioAnalysis/wasmConfig.ts

@@ -1,6 +1,6 @@
 // Version is inlined here — keep in sync with package.json when releasing.
 // The publish.sh script should bump this string alongside package.json.
-const WASM_VERSION = '3.0.2-beta.1'
+const WASM_VERSION = '3.0.2'
 // jsDelivr syncs from npm automatically within ~5 min of publish.
 // GitHub release fallback (attach mel-spectrogram.js as a release asset):
 //   https://github.com/deeeed/audiolab/releases/download/@siteed/audio-studio@VERSION/mel-spectrogram.js
@@ -8,15 +8,15 @@ const WASM_VERSION = '3.0.2-beta.1'
 const DEFAULT_WASM_CDN = `https://cdn.jsdelivr.net/npm/@siteed/audio-studio@${WASM_VERSION}/prebuilt/wasm/mel-spectrogram.js`
 
 let _wasmUrl: string = DEFAULT_WASM_CDN
-let _modulePromiseReset: (() => void) | null = null
+const _resetListeners: Array<() => void> = []
 
 export function _registerModuleReset(fn: () => void): void {
-    _modulePromiseReset = fn
+    _resetListeners.push(fn)
 }
 
 export function setMelSpectrogramWasmUrl(url: string): void {
     _wasmUrl = url
-    _modulePromiseReset?.() // invalidate cached module so next call re-fetches
+    _resetListeners.forEach((fn) => fn())
 }
 
 export function getMelSpectrogramWasmUrl(): string {

package/src/AudioAnalysis/wasmLoader.web.ts

@@ -0,0 +1,48 @@
+import type { AudioFeaturesWasmModule } from './audio-features-wasm'
+import { getMelSpectrogramWasmUrl, _registerModuleReset } from './wasmConfig'
+
+// Global factory name for the shared WASM binary. Despite the name referring to
+// mel spectrogram, this single binary also exports all audio-features functions.
+const WASM_GLOBAL_NAME = 'createMelSpectrogramModule'
+let modulePromise: Promise<AudioFeaturesWasmModule> | null = null
+
+_registerModuleReset(() => {
+    modulePromise = null
+})
+
+function loadScriptTag(url: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const script = document.createElement('script')
+        script.src = url
+        script.onload = () => resolve()
+        script.onerror = () => reject(new Error(`Failed to load script: ${url}`))
+        document.head.appendChild(script)
+    })
+}
+
+export function getWasmModule(): Promise<AudioFeaturesWasmModule> {
+    if (!modulePromise) {
+        modulePromise = (async () => {
+            const url = getMelSpectrogramWasmUrl()
+            // Try ESM import first; fall back to <script> tag for UMD modules
+            const mod = await import(/* webpackIgnore: true */ /* @vite-ignore */ url)
+            let factory: unknown = mod.default ?? mod
+            if (typeof factory !== 'function') {
+                // UMD fallback: load via <script> tag so the top-level `var` becomes a global and
+                // document.currentScript.src is set (Emscripten uses it to locate the .wasm binary).
+                await loadScriptTag(url)
+                factory = (globalThis as Record<string, unknown>)[WASM_GLOBAL_NAME]
+            }
+            if (typeof factory !== 'function') {
+                throw new TypeError(
+                    `WASM factory '${WASM_GLOBAL_NAME}' not found after loading ${url}`
+                )
+            }
+            return (factory as () => Promise<AudioFeaturesWasmModule>)()
+        })().catch((err) => {
+            modulePromise = null
+            throw err
+        })
+    }
+    return modulePromise
+}