@siteed/audio-studio 3.0.0

package/src/utils/writeWavHeader.ts

@@ -0,0 +1,115 @@
+// packages/audio-studio/src/utils/writeWavHeader.ts
+
+/**
+ * Options for creating a WAV header.
+ */
+export interface WavHeaderOptions {
+    /** Optional buffer containing audio data. If provided, it will be combined with the header. */
+    buffer?: ArrayBuffer
+    /** The sample rate of the audio in Hz (e.g., 44100). */
+    sampleRate: number
+    /** The number of audio channels (e.g., 1 for mono, 2 for stereo). */
+    numChannels: number
+    /** The bit depth of the audio (e.g., 16, 24, or 32). */
+    bitDepth: number
+    /** Whether the audio data is in float format (only applies to 32-bit) */
+    isFloat?: boolean
+}
+
+/**
+ * Writes or updates a WAV (RIFF) header based on the provided options.
+ *
+ * This function can be used in three ways:
+ * 1. To create a standalone WAV header (when no buffer is provided).
+ * 2. To create a WAV header and combine it with existing audio data (when a buffer without a header is provided).
+ * 3. To update an existing WAV header in the provided buffer.
+ *
+ * For streaming audio where the final size is unknown, this function sets the size fields
+ * to the maximum 32-bit value (0xFFFFFFFF). These can be updated later using the
+ * `updateWavHeaderSize` function once the final size is known.
+ *
+ * @param options - The options for creating or updating the WAV header.
+ * @returns An ArrayBuffer containing the WAV header, or the header combined with the provided audio data.
+ *
+ * @throws {Error} Throws an error if the provided options are invalid or if the buffer is too small.
+ */
+export const writeWavHeader = ({
+    buffer,
+    sampleRate,
+    numChannels,
+    bitDepth,
+    isFloat = bitDepth === 32, // Default to float for 32-bit
+}: WavHeaderOptions): ArrayBuffer => {
+    // For 32-bit float, we use format 3, otherwise format 1 for PCM
+    const audioFormat = isFloat ? 3 : 1 // 3 = IEEE float, 1 = PCM
+
+    const bytesPerSample = bitDepth / 8
+    const blockAlign = numChannels * bytesPerSample
+    const byteRate = sampleRate * blockAlign
+
+    // Function to write a string to the DataView
+    const writeString = (view: DataView, offset: number, string: string) => {
+        for (let i = 0; i < string.length; i++) {
+            view.setUint8(offset + i, string.charCodeAt(i))
+        }
+    }
+
+    // Function to write or update the header
+    const writeHeader = (view: DataView, dataSize: number = 0xffffffff) => {
+        // RIFF chunk descriptor
+        writeString(view, 0, 'RIFF') // ChunkID
+        view.setUint32(4, 36 + dataSize, true) // ChunkSize: 4 + (8 + 16) + (8 + dataSize)
+        writeString(view, 8, 'WAVE') // Format
+
+        // "fmt " sub-chunk
+        writeString(view, 12, 'fmt ') // Subchunk1ID
+        view.setUint32(16, 16, true) // Subchunk1Size (16 for PCM/Float)
+        view.setUint16(20, audioFormat, true) // AudioFormat (3 for float, 1 for PCM)
+        view.setUint16(22, numChannels, true) // NumChannels
+        view.setUint32(24, sampleRate, true) // SampleRate
+        view.setUint32(28, byteRate, true) // ByteRate = SampleRate * NumChannels * BitsPerSample/8
+        view.setUint16(32, blockAlign, true) // BlockAlign = NumChannels * BitsPerSample/8
+        view.setUint16(34, bitDepth, true) // BitsPerSample
+
+        // "data" sub-chunk
+        writeString(view, 36, 'data') // Subchunk2ID
+        view.setUint32(40, dataSize, true) // Subchunk2Size = NumSamples * NumChannels * BitsPerSample/8
+    }
+
+    if (buffer) {
+        // Handle existing buffer
+
+        // Check for minimum size
+        if (buffer.byteLength < 44) {
+            throw new Error('Buffer is too small to contain a valid WAV header')
+        }
+
+        const view = new DataView(buffer)
+
+        // Check if the buffer already has a WAV header by looking for "RIFF" at the start
+        const existingHeader = view.getUint32(0, false) === 0x52494646 // "RIFF" in ASCII
+
+        if (existingHeader) {
+            // Update the existing header
+            writeHeader(view, buffer.byteLength - 44)
+            return buffer
+        } else {
+            // Create a new buffer with header + data
+            const newBuffer = new ArrayBuffer(44 + buffer.byteLength)
+            const newView = new DataView(newBuffer)
+
+            // Write header to new buffer
+            writeHeader(newView, buffer.byteLength)
+
+            // Copy audio data after header
+            new Uint8Array(newBuffer).set(new Uint8Array(buffer), 44)
+            return newBuffer
+        }
+    } else {
+        // Create standalone header
+        const headerBuffer = new ArrayBuffer(44)
+        const view = new DataView(headerBuffer)
+        writeHeader(view)
+        return headerBuffer
+    }
+}

package/src/workers/InlineFeaturesExtractor.web.tsx

@@ -0,0 +1,291 @@
+// packages/audio-studio/src/workers/InlineFeaturesExtractor.web.tsx
+//
+// The worker blob is assembled at runtime by concatenating:
+//   1. The WASM glue JS string (defines createMelSpectrogramModule)
+//   2. This inline worker code
+//
+// This keeps ONE C++ implementation for spectral/MFCC/chroma across all platforms.
+
+export const InlineFeaturesExtractor = `
+// --- Constants ---
+const N_FFT = 1024;
+const N_CHROMA = 12;
+const STRUCT_SIZE = 32; // CAudioFeaturesResult
+
+// --- WASM module state ---
+let wasmModule = null;
+let wasmInitPromise = null;
+let wasmFramePtr = 0;
+let wasmFrameCapacity = 0;
+let wasmResultPtr = 0;
+
+function initWasm(sampleRate) {
+    if (wasmInitPromise) return wasmInitPromise;
+    wasmInitPromise = (typeof createMelSpectrogramModule === 'function'
+        ? createMelSpectrogramModule()
+        : Promise.reject(new Error('WASM glue not loaded'))
+    ).then(function(Module) {
+        wasmModule = Module;
+        Module._audio_features_init(sampleRate, N_FFT, 13, 26, 1, 1);
+        wasmResultPtr = Module._malloc(STRUCT_SIZE);
+        Module.HEAPU8.fill(0, wasmResultPtr, wasmResultPtr + STRUCT_SIZE);
+        return Module;
+    }).catch(function(err) {
+        wasmInitPromise = null;
+        throw err;
+    });
+    return wasmInitPromise;
+}
+
+function readWasmResult(Module, ptr) {
+    var getValue = Module.getValue;
+    var centroid = getValue(ptr, 'float');
+    var flatness = getValue(ptr + 4, 'float');
+    var rolloff  = getValue(ptr + 8, 'float');
+    var bandwidth = getValue(ptr + 12, 'float');
+    var mfccPtr = getValue(ptr + 16, 'i32');
+    var mfccCount = getValue(ptr + 20, 'i32');
+    var chromaPtr = getValue(ptr + 24, 'i32');
+    var chromaCount = getValue(ptr + 28, 'i32');
+
+    var mfcc = [];
+    if (mfccPtr && mfccCount > 0) {
+        var off = mfccPtr >> 2;
+        for (var i = 0; i < mfccCount; i++) mfcc.push(Module.HEAPF32[off + i]);
+    }
+    var chromagram = [];
+    if (chromaPtr && chromaCount > 0) {
+        var off2 = chromaPtr >> 2;
+        for (var i = 0; i < chromaCount; i++) chromagram.push(Module.HEAPF32[off2 + i]);
+    }
+    return { centroid: centroid, flatness: flatness, rolloff: rolloff, bandwidth: bandwidth, mfcc: mfcc, chromagram: chromagram };
+}
+
+// Compute spectral/MFCC/chroma features for a segment via WASM C++
+function computeFeaturesWasm(segment, sampleRate, featureOptions) {
+    if (!wasmModule || !wasmResultPtr) {
+        return { centroid: 0, flatness: 0, rolloff: 0, bandwidth: 0, mfcc: [], chromagram: [] };
+    }
+    var Module = wasmModule;
+    var needSpectral = featureOptions.spectralCentroid || featureOptions.spectralFlatness ||
+                       featureOptions.spectralRolloff || featureOptions.spectralBandwidth;
+    var needMfcc = !!featureOptions.mfcc;
+    var needChroma = !!featureOptions.chromagram;
+
+    if (!needSpectral && !needMfcc && !needChroma) {
+        return { centroid: 0, flatness: 0, rolloff: 0, bandwidth: 0, mfcc: [], chromagram: [] };
+    }
+
+    // Re-init if needed (different feature flags)
+    Module._audio_features_init(sampleRate, N_FFT, 13, 26, needMfcc ? 1 : 0, needChroma ? 1 : 0);
+
+    // Allocate/grow input buffer on WASM heap
+    if (segment.length > wasmFrameCapacity) {
+        if (wasmFramePtr) Module._free(wasmFramePtr);
+        wasmFramePtr = Module._malloc(segment.length * 4);
+        wasmFrameCapacity = segment.length;
+    }
+    Module.HEAPF32.set(segment, wasmFramePtr >> 2);
+
+    var ok = Module._audio_features_compute_frame(wasmFramePtr, segment.length, wasmResultPtr);
+    if (!ok) {
+        return { centroid: 0, flatness: 0, rolloff: 0, bandwidth: 0, mfcc: [], chromagram: [] };
+    }
+    var result = readWasmResult(Module, wasmResultPtr);
+    Module._audio_features_free_arrays(wasmResultPtr);
+    return result;
+}
+
+// --- JS fallback for HNR (autocorrelation, no FFT needed) ---
+function extractHNR(segmentData) {
+    var frameSize = segmentData.length;
+    var autocorrelation = new Float32Array(frameSize);
+    for (var i = 0; i < frameSize; i++) {
+        var sum = 0;
+        for (var j = 0; j < frameSize - i; j++) {
+            sum += segmentData[j] * segmentData[j + i];
+        }
+        autocorrelation[i] = sum;
+    }
+    var maxAutocorrelation = -Infinity;
+    for (var i = 1; i < autocorrelation.length; i++) {
+        if (autocorrelation[i] > maxAutocorrelation) {
+            maxAutocorrelation = autocorrelation[i];
+        }
+    }
+    return autocorrelation[0] !== 0
+        ? 10 * Math.log10(maxAutocorrelation / (autocorrelation[0] - maxAutocorrelation))
+        : 0;
+}
+
+// --- JS fallback for pitch estimation (simple peak-picking) ---
+function estimatePitch(segment, sampleRate) {
+    if (!segment || segment.length < 2 || !sampleRate) return 0;
+    // Simple autocorrelation-based pitch
+    var minLag = Math.floor(sampleRate / 1000); // 1000 Hz max
+    var maxLag = Math.floor(sampleRate / 50);   // 50 Hz min
+    if (maxLag >= segment.length) maxLag = segment.length - 1;
+    var bestCorr = -Infinity;
+    var bestLag = 0;
+    for (var lag = minLag; lag <= maxLag; lag++) {
+        var corr = 0;
+        for (var i = 0; i < segment.length - lag; i++) {
+            corr += segment[i] * segment[i + lag];
+        }
+        if (corr > bestCorr) {
+            bestCorr = corr;
+            bestLag = lag;
+        }
+    }
+    return bestLag > 0 ? sampleRate / bestLag : 0;
+}
+
+// --- Unique ID counter ---
+let uniqueIdCounter = 0;
+
+// --- Message handler ---
+self.onmessage = function (event) {
+    var enableLogging = event.data.enableLogging || false;
+
+    // Reset command
+    if (event.data.command === 'resetCounter') {
+        var newValue = event.data.value;
+        uniqueIdCounter = typeof newValue === 'number' ? newValue : 0;
+        return;
+    }
+
+    var channelData = event.data.channelData;
+    var sampleRate = event.data.sampleRate;
+    var segmentDurationMs = event.data.segmentDurationMs;
+    var bitDepth = event.data.bitDepth;
+    var fullAudioDurationMs = event.data.fullAudioDurationMs;
+    var numberOfChannels = event.data.numberOfChannels;
+    var _features = event.data.features;
+    var features = _features || {};
+    var bytesPerSample = bitDepth / 8;
+
+    var subChunkStartTime = (typeof fullAudioDurationMs === 'number' && !isNaN(fullAudioDurationMs) && fullAudioDurationMs >= 0)
+                            ? fullAudioDurationMs / 1000 : 0;
+
+    // Check if any C++-backed features are requested
+    var needWasm = features.spectralCentroid || features.spectralFlatness ||
+                   features.spectralRolloff || features.spectralBandwidth ||
+                   features.mfcc || features.chromagram;
+
+    function createFeaturesObject(maxAmp, rms, sumSquares, zeroCrossings, segLen, wasmResult, startIdx, endIdx) {
+        if (!Object.values(features).some(function(v) { return v; })) return undefined;
+        var result = {};
+        if (features.energy) result.energy = sumSquares;
+        if (features.rms) result.rms = rms;
+        result.minAmplitude = -maxAmp;
+        result.maxAmplitude = maxAmp;
+        if (features.zcr) result.zcr = zeroCrossings / segLen;
+        if (features.spectralCentroid) result.spectralCentroid = wasmResult.centroid;
+        if (features.spectralFlatness) result.spectralFlatness = wasmResult.flatness;
+        if (features.spectralRolloff) result.spectralRolloff = wasmResult.rolloff;
+        if (features.spectralBandwidth) result.spectralBandwidth = wasmResult.bandwidth;
+        if (features.mfcc) result.mfcc = wasmResult.mfcc;
+        if (features.chromagram) result.chromagram = wasmResult.chromagram;
+        if (features.hnr) result.hnr = extractHNR(channelData.slice(startIdx, endIdx));
+        if (features.pitch) result.pitch = estimatePitch(channelData.slice(startIdx, endIdx), sampleRate);
+        return result;
+    }
+
+    function processSegment(startIdx, endIdx, segLen) {
+        var sumSquares = 0, maxAmp = 0, zeroCrossings = 0;
+        for (var j = startIdx; j < endIdx; j++) {
+            var value = channelData[j];
+            sumSquares += value * value;
+            if (Math.abs(value) > maxAmp) maxAmp = Math.abs(value);
+            if (j > 0 && value * channelData[j - 1] < 0) zeroCrossings++;
+        }
+        var rms = Math.sqrt(sumSquares / segLen);
+        var wasmResult = needWasm
+            ? computeFeaturesWasm(channelData.slice(startIdx, endIdx), sampleRate, features)
+            : { centroid: 0, flatness: 0, rolloff: 0, bandwidth: 0, mfcc: [], chromagram: [] };
+
+        var dataPoint = {
+            id: uniqueIdCounter++,
+            amplitude: maxAmp,
+            rms: rms,
+            startTime: subChunkStartTime + (startIdx / sampleRate),
+            endTime: subChunkStartTime + (endIdx / sampleRate),
+            dB: 20 * Math.log10(rms + 1e-6),
+            silent: rms < 0.01,
+            startPosition: startIdx * (numberOfChannels || 1) * bytesPerSample,
+            endPosition: endIdx * (numberOfChannels || 1) * bytesPerSample,
+            samples: segLen,
+        };
+        var ef = createFeaturesObject(maxAmp, rms, sumSquares, zeroCrossings, segLen, wasmResult, startIdx, endIdx);
+        if (ef) dataPoint.features = ef;
+        return dataPoint;
+    }
+
+    function extractWaveform() {
+        var totalSamples = channelData.length;
+        var durationMs = (totalSamples / sampleRate) * 1000;
+        var samplesPerSegment = Math.floor(sampleRate * (segmentDurationMs / 1000));
+        var numPoints = Math.floor(totalSamples / samplesPerSegment);
+        var remainingSamples = totalSamples % samplesPerSegment;
+
+        var min = Infinity, max = -Infinity;
+        for (var i = 0; i < totalSamples; i++) {
+            if (channelData[i] < min) min = channelData[i];
+            if (channelData[i] > max) max = channelData[i];
+        }
+
+        var dataPoints = [];
+        for (var i = 0; i < numPoints; i++) {
+            var startIdx = i * samplesPerSegment;
+            dataPoints.push(processSegment(startIdx, startIdx + samplesPerSegment, samplesPerSegment));
+        }
+        if (remainingSamples > samplesPerSegment / 4) {
+            var startIdx = numPoints * samplesPerSegment;
+            dataPoints.push(processSegment(startIdx, totalSamples, totalSamples - startIdx));
+        }
+        return {
+            durationMs: durationMs,
+            dataPoints: dataPoints,
+            amplitudeRange: { min: min, max: max },
+            rmsRange: { min: 0, max: Math.max(Math.abs(min), Math.abs(max)) }
+        };
+    }
+
+    // Main: init WASM if needed, then process
+    var doProcess = function() {
+        try {
+            var t0 = performance.now();
+            var result = extractWaveform();
+            var t1 = performance.now();
+            self.postMessage({
+                command: 'features',
+                result: {
+                    bitDepth: bitDepth,
+                    samples: channelData.length,
+                    numberOfChannels: numberOfChannels,
+                    sampleRate: sampleRate,
+                    segmentDurationMs: segmentDurationMs,
+                    durationMs: result.durationMs,
+                    dataPoints: result.dataPoints,
+                    amplitudeRange: result.amplitudeRange,
+                    rmsRange: result.rmsRange,
+                    extractionTimeMs: t1 - t0,
+                }
+            });
+        } catch (error) {
+            console.error('[Worker] Error', { message: error.message, stack: error.stack });
+            self.postMessage({ error: { message: error.message, stack: error.stack, name: error.name } });
+        }
+    };
+
+    if (needWasm && !wasmModule) {
+        initWasm(sampleRate).then(doProcess).catch(function(e) {
+            console.error('[Worker] WASM init failed, processing without WASM:', e);
+            needWasm = false;
+            doProcess();
+        });
+    } else {
+        doProcess();
+    }
+};
+`

package/src/workers/inlineAudioWebWorker.web.tsx

@@ -0,0 +1,186 @@
+// packages/audio-studio/src/workers/inlineAudioWebWorker.web.tsx
+export const InlineAudioWebWorker = `
+const DEFAULT_BIT_DEPTH = 32
+const DEFAULT_SAMPLE_RATE = 44100
+
+class RecorderProcessor extends AudioWorkletProcessor {
+    constructor() {
+        super()
+        this.currentChunk = [] // Float32Array
+        this.samplesSinceLastExport = 0
+        this.recordSampleRate = DEFAULT_SAMPLE_RATE
+        this.exportSampleRate = DEFAULT_SAMPLE_RATE
+        this.recordBitDepth = DEFAULT_BIT_DEPTH
+        this.exportBitDepth = DEFAULT_BIT_DEPTH
+        this.numberOfChannels = 1
+        this.isRecording = true
+        this.port.onmessage = this.handleMessage.bind(this)
+        this.enableLogging = false
+        this.exportIntervalSamples = 0
+        this.currentPosition = 0 // Track current position in seconds
+        this.streamFormat = 'raw'
+    }
+
+    handleMessage(event) {
+        switch (event.data.command) {
+            case 'init':
+                this.enableLogging = event.data.enableLogging || false
+                this.recordSampleRate = event.data.recordSampleRate
+                this.exportSampleRate =
+                    event.data.exportSampleRate || event.data.recordSampleRate
+                this.exportIntervalSamples =
+                    this.recordSampleRate * (event.data.interval / 1000)
+                if (event.data.numberOfChannels) {
+                    this.numberOfChannels = event.data.numberOfChannels
+                }
+                if (event.data.recordBitDepth) {
+                    this.recordBitDepth = event.data.recordBitDepth
+                }
+                this.exportBitDepth =
+                    event.data.exportBitDepth || this.recordBitDepth
+                this.streamFormat = event.data.streamFormat || 'raw'
+                
+                // Handle position parameter for device switching
+                if (typeof event.data.position === 'number' && event.data.position > 0) {
+                    this.currentPosition = event.data.position
+                    if (this.enableLogging) {
+                        console.log('AudioWorklet initialized with position:', this.currentPosition)
+                    }
+                }
+                break
+
+            case 'stop':
+                this.isRecording = false
+                if (this.currentChunk.length > 0) {
+                    this.processChunk()
+                }
+                break
+                
+            case 'pause':
+                // Just a placeholder for pause handling
+                break
+                
+            case 'resume':
+                // Just a placeholder for resume handling
+                break
+        }
+    }
+
+    process(inputs, _outputs, _parameters) {
+        if (!this.isRecording) return true
+        const input = inputs[0]
+        if (input.length > 0) {
+            const newBuffer = new Float32Array(input[0])
+            this.currentChunk.push(newBuffer)
+            this.samplesSinceLastExport += newBuffer.length
+
+            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {
+                this.processChunk()
+                this.samplesSinceLastExport = 0
+            }
+        }
+        return true
+    }
+
+    mergeBuffers(bufferArray, recLength) {
+        const result = new Float32Array(recLength)
+        let offset = 0
+        for (let i = 0; i < bufferArray.length; i++) {
+            result.set(bufferArray[i], offset)
+            offset += bufferArray[i].length
+        }
+        return result
+    }
+
+    // Keep basic resampling for sample rate conversion
+    resample(samples, targetSampleRate) {
+        if (this.recordSampleRate === targetSampleRate) {
+            return samples
+        }
+        const resampledBuffer = new Float32Array(
+            Math.ceil(
+                (samples.length * targetSampleRate) / this.recordSampleRate
+            )
+        )
+        const ratio = this.recordSampleRate / targetSampleRate
+        let offset = 0
+        for (let i = 0; i < resampledBuffer.length; i++) {
+            const nextOffset = Math.floor((i + 1) * ratio)
+            let accum = 0
+            let count = 0
+            for (let j = offset; j < nextOffset && j < samples.length; j++) {
+                accum += samples[j]
+                count++
+            }
+            resampledBuffer[i] = count > 0 ? accum / count : 0
+            offset = nextOffset
+        }
+        return resampledBuffer
+    }
+
+    // Keep bit depth conversion if needed
+    convertBitDepth(input, targetBitDepth) {
+        if (targetBitDepth === 32) {
+            const output = new Int32Array(input.length)
+            for (let i = 0; i < input.length; i++) {
+                const s = Math.max(-1, Math.min(1, input[i]))
+                output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff
+            }
+            return output
+        } else if (targetBitDepth === 16) {
+            const output = new Int16Array(input.length)
+            for (let i = 0; i < input.length; i++) {
+                const s = Math.max(-1, Math.min(1, input[i]))
+                output[i] = s < 0 ? s * 0x8000 : s * 0x7fff
+            }
+            return output
+        }
+        return input
+    }
+
+    processChunk() {
+        if (this.currentChunk.length === 0) return
+
+        // Merge buffers
+        const chunkLength = this.currentChunk.reduce(
+            (acc, buf) => acc + buf.length,
+            0
+        )
+        const mergedChunk = this.mergeBuffers(this.currentChunk, chunkLength)
+
+        // Resample if needed
+        const resampledChunk = this.resample(mergedChunk, this.exportSampleRate)
+
+        // Convert bit depth if needed (used for file storage format)
+        const finalBuffer =
+            this.recordBitDepth !== this.exportBitDepth
+                ? this.convertBitDepth(resampledChunk, this.exportBitDepth)
+                : resampledChunk
+
+        // For float32 stream format, send the resampled Float32 data directly
+        // (skipping the bit-depth conversion roundtrip)
+        const streamData = this.streamFormat === 'float32' ? resampledChunk : finalBuffer
+
+        // Calculate the duration in seconds
+        const chunkDuration = resampledChunk.length / this.exportSampleRate
+
+        // Send processed chunk with the current position
+        this.port.postMessage({
+            command: 'newData',
+            recordedData: streamData,
+            sampleRate: this.exportSampleRate,
+            bitDepth: this.exportBitDepth,
+            numberOfChannels: this.numberOfChannels,
+            position: this.currentPosition,
+        })
+        
+        // Update the position
+        this.currentPosition += chunkDuration
+
+        // Clear the current chunk
+        this.currentChunk = []
+    }
+}
+
+registerProcessor('recorder-processor', RecorderProcessor)
+`