@siteed/audio-studio 3.0.0

package/build/esm/utils/writeWavHeader.js.map

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

package/build/esm/workers/InlineFeaturesExtractor.web.js

@@ -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();
+    }
+};
+`;
+//# sourceMappingURL=InlineFeaturesExtractor.web.js.map

package/build/esm/workers/InlineFeaturesExtractor.web.js.map

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

package/build/esm/workers/inlineAudioWebWorker.web.js

@@ -0,0 +1,187 @@
+// 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)
+`;
+//# sourceMappingURL=inlineAudioWebWorker.web.js.map

package/build/esm/workers/inlineAudioWebWorker.web.js.map

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