@siteed/audio-studio 3.0.0

package/build/types/utils/convertPCMToFloat32.d.ts

@@ -0,0 +1,13 @@
+import { ConsoleLike } from '../AudioStudio.types';
+export declare const WAV_HEADER_SIZE = 44;
+export declare const convertPCMToFloat32: ({ bitDepth, buffer, skipWavHeader, logger, }: {
+    buffer: ArrayBuffer;
+    bitDepth: number;
+    skipWavHeader?: boolean;
+    logger?: ConsoleLike;
+}) => Promise<{
+    pcmValues: Float32Array;
+    min: number;
+    max: number;
+}>;
+//# sourceMappingURL=convertPCMToFloat32.d.ts.map

package/build/types/utils/convertPCMToFloat32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertPCMToFloat32.d.ts","sourceRoot":"","sources":["../../../src/utils/convertPCMToFloat32.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAGlD,eAAO,MAAM,eAAe,KAAK,CAAA;AA+DjC,eAAO,MAAM,mBAAmB,GAAU,8CAKvC;IACC,MAAM,EAAE,WAAW,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,MAAM,CAAC,EAAE,WAAW,CAAA;CACvB,KAAG,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CA2FhE,CAAA"}

package/build/types/utils/crc32.d.ts

@@ -0,0 +1,7 @@
+export interface CRC32 {
+    (data: string | Uint8Array): number;
+    buf(data: Uint8Array): number;
+}
+declare let crc32Implementation: CRC32;
+export default crc32Implementation;
+//# sourceMappingURL=crc32.d.ts.map

package/build/types/utils/crc32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crc32.d.ts","sourceRoot":"","sources":["../../../src/utils/crc32.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,KAAK;IAClB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAA;IACnC,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAA;CAChC;AAsCD,QAAA,IAAI,mBAAmB,EAAE,KAAK,CAAA;AAY9B,eAAe,mBAAmB,CAAA"}

package/build/types/utils/encodingToBitDepth.d.ts

@@ -0,0 +1,5 @@
+import { BitDepth, EncodingType } from '../AudioStudio.types';
+export declare const encodingToBitDepth: ({ encoding, }: {
+    encoding: EncodingType;
+}) => BitDepth;
+//# sourceMappingURL=encodingToBitDepth.d.ts.map

package/build/types/utils/encodingToBitDepth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodingToBitDepth.d.ts","sourceRoot":"","sources":["../../../src/utils/encodingToBitDepth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAE7D,eAAO,MAAM,kBAAkB,GAAI,eAEhC;IACC,QAAQ,EAAE,YAAY,CAAA;CACzB,KAAG,QAWH,CAAA"}

package/build/types/utils/getWavFileInfo.d.ts

@@ -0,0 +1,26 @@
+import { BitDepth, SampleRate } from '../AudioStudio.types';
+/**
+ * Interface representing the metadata of a WAV file.
+ */
+export interface WavFileInfo {
+    sampleRate: SampleRate;
+    numChannels: number;
+    bitDepth: BitDepth;
+    size: number;
+    durationMs: number;
+    audioFormatDescription: string;
+    byteRate: number;
+    blockAlign: number;
+    creationDateTime?: string;
+    comments?: string;
+    compressionType?: string;
+    dataChunkOffset: number;
+}
+/**
+ * Extracts metadata from a WAV buffer.
+ *
+ * @param arrayBuffer - The array buffer containing the WAV data.
+ * @returns A promise that resolves to the extracted metadata.
+ */
+export declare const getWavFileInfo: (arrayBuffer: ArrayBuffer) => Promise<WavFileInfo>;
+//# sourceMappingURL=getWavFileInfo.d.ts.map

package/build/types/utils/getWavFileInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWavFileInfo.d.ts","sourceRoot":"","sources":["../../../src/utils/getWavFileInfo.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAoB3D;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,eAAe,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACvB,aAAa,WAAW,KACzB,OAAO,CAAC,WAAW,CAmFrB,CAAA"}

package/build/types/utils/writeWavHeader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 declare const writeWavHeader: ({ buffer, sampleRate, numChannels, bitDepth, isFloat, }: WavHeaderOptions) => ArrayBuffer;
+//# sourceMappingURL=writeWavHeader.d.ts.map

package/build/types/utils/writeWavHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeWavHeader.d.ts","sourceRoot":"","sources":["../../../src/utils/writeWavHeader.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,+FAA+F;IAC/F,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAA;IAClB,qEAAqE;IACrE,WAAW,EAAE,MAAM,CAAA;IACnB,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAA;IAChB,yEAAyE;IACzE,OAAO,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GAAI,yDAM5B,gBAAgB,KAAG,WAyErB,CAAA"}

package/build/types/workers/InlineFeaturesExtractor.web.d.ts

@@ -0,0 +1,2 @@
+export declare 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";
+//# sourceMappingURL=InlineFeaturesExtractor.web.d.ts.map

package/build/types/workers/InlineFeaturesExtractor.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineFeaturesExtractor.web.d.ts","sourceRoot":"","sources":["../../../src/workers/InlineFeaturesExtractor.web.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,uBAAuB,w/WA0RnC,CAAA"}

package/build/types/workers/inlineAudioWebWorker.web.d.ts

@@ -0,0 +1,2 @@
+export declare 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";
+//# sourceMappingURL=inlineAudioWebWorker.web.d.ts.map

package/build/types/workers/inlineAudioWebWorker.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineAudioWebWorker.web.d.ts","sourceRoot":"","sources":["../../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AACA,eAAO,MAAM,oBAAoB,4tNAwLhC,CAAA"}

package/build/types/workers/wasmGlueString.web.d.ts

@@ -0,0 +1,2 @@
+export declare const wasmGlueJs: string;
+//# sourceMappingURL=wasmGlueString.web.d.ts.map

package/build/types/workers/wasmGlueString.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasmGlueString.web.d.ts","sourceRoot":"","sources":["../../../src/workers/wasmGlueString.web.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,EAAE,MAkBxB,CAAC"}

package/cpp/AudioFeatures.cpp

@@ -0,0 +1,274 @@
+#include "AudioFeatures.h"
+
+#include <algorithm>
+#include <cstring>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+AudioFeaturesProcessor::AudioFeaturesProcessor(const AudioFeaturesConfig& config)
+    : config_(config), fftCfg_(nullptr) {
+    if (config_.sampleRate <= 0) config_.sampleRate = 16000;
+    if (config_.fftLength <= 0) config_.fftLength = 1024;
+    if (config_.nMfcc <= 0) config_.nMfcc = 13;
+    if (config_.nMelFilters <= 0) config_.nMelFilters = 26;
+    numBins_ = config_.fftLength / 2 + 1;
+    fftCfg_ = kiss_fftr_alloc(config_.fftLength, 0, nullptr, nullptr);
+    buildWindow();
+    if (config_.computeMfcc) {
+        buildMelFilterbank();
+        buildDCTMatrix();
+    }
+    allocateBuffers();
+}
+
+AudioFeaturesProcessor::~AudioFeaturesProcessor() {
+    if (fftCfg_) {
+        free(fftCfg_);
+    }
+}
+
+void AudioFeaturesProcessor::allocateBuffers() {
+    fftInput_.resize(config_.fftLength, 0.0f);
+    fftOutput_.resize(numBins_);
+    magnitudeSpectrum_.resize(numBins_, 0.0f);
+    powerSpectrum_.resize(numBins_, 0.0f);
+}
+
+float AudioFeaturesProcessor::hzToMel(float hz) {
+    return 2595.0f * std::log10(1.0f + hz / 700.0f);
+}
+
+float AudioFeaturesProcessor::melToHz(float mel) {
+    return 700.0f * (std::pow(10.0f, mel / 2595.0f) - 1.0f);
+}
+
+void AudioFeaturesProcessor::buildWindow() {
+    window_.resize(config_.fftLength);
+    const float N = static_cast<float>(config_.fftLength - 1);
+    for (int i = 0; i < config_.fftLength; ++i) {
+        // Hann window
+        window_[i] = 0.5f * (1.0f - std::cos(2.0f * static_cast<float>(M_PI) * i / N));
+    }
+}
+
+void AudioFeaturesProcessor::buildMelFilterbank() {
+    const float fMin = 0.0f;
+    const float fMax = static_cast<float>(config_.sampleRate) / 2.0f;
+    const float melMin = hzToMel(fMin);
+    const float melMax = hzToMel(fMax);
+
+    // nMelFilters + 2 points for triangular filters
+    const int nPoints = config_.nMelFilters + 2;
+    std::vector<float> melPoints(nPoints);
+    for (int i = 0; i < nPoints; ++i) {
+        float mel = melMin + i * (melMax - melMin) / (config_.nMelFilters + 1);
+        melPoints[i] = melToHz(mel);
+    }
+
+    const float binWidth = static_cast<float>(config_.sampleRate) / config_.fftLength;
+
+    melFilters_.resize(config_.nMelFilters);
+    for (int m = 0; m < config_.nMelFilters; ++m) {
+        const float fLow = melPoints[m];
+        const float fCenter = melPoints[m + 1];
+        const float fHigh = melPoints[m + 2];
+
+        int binStart = std::max(0, static_cast<int>(std::ceil(fLow / binWidth)));
+        int binEnd = std::min(numBins_ - 1, static_cast<int>(std::floor(fHigh / binWidth)));
+
+        melFilters_[m].startBin = binStart;
+        const int count = binEnd - binStart + 1;
+        melFilters_[m].weights.resize(count > 0 ? count : 0);
+
+        for (int bin = binStart; bin <= binEnd; ++bin) {
+            float freq = static_cast<float>(bin) * binWidth;
+            float weight;
+            if (freq <= fCenter) {
+                weight = (fCenter - fLow) > 0.0f ? (freq - fLow) / (fCenter - fLow) : 0.0f;
+            } else {
+                weight = (fHigh - fCenter) > 0.0f ? (fHigh - freq) / (fHigh - fCenter) : 0.0f;
+            }
+            melFilters_[m].weights[bin - binStart] = std::max(0.0f, weight);
+        }
+    }
+}
+
+void AudioFeaturesProcessor::buildDCTMatrix() {
+    // Precompute DCT-II matrix: dct[i][j] = scale * cos(pi * i * (2*j + 1) / (2*N))
+    const int N = config_.nMelFilters;
+    const int K = config_.nMfcc;
+    const float scale = std::sqrt(2.0f / N);
+
+    dctMatrix_.resize(K * N);
+    for (int i = 0; i < K; ++i) {
+        for (int j = 0; j < N; ++j) {
+            dctMatrix_[i * N + j] = scale * std::cos(
+                static_cast<float>(M_PI) * i * (2 * j + 1) / (2.0f * N)
+            );
+        }
+    }
+}
+
+void AudioFeaturesProcessor::computeFFT(const float* samples, int numSamples) {
+    float* fftIn = fftInput_.data();
+
+    // Zero the buffer
+    std::memset(fftIn, 0, config_.fftLength * sizeof(float));
+
+    // Apply window to input (truncate or zero-pad as needed)
+    const int len = std::min(numSamples, config_.fftLength);
+    for (int i = 0; i < len; ++i) {
+        fftIn[i] = samples[i] * window_[i];
+    }
+
+    // Compute real FFT
+    kiss_fftr(fftCfg_, fftIn, fftOutput_.data());
+
+    // Compute magnitude and power spectra
+    for (int i = 0; i < numBins_; ++i) {
+        float re = fftOutput_[i].r;
+        float im = fftOutput_[i].i;
+        float power = re * re + im * im;
+        powerSpectrum_[i] = power;
+        magnitudeSpectrum_[i] = std::sqrt(power);
+    }
+}
+
+float AudioFeaturesProcessor::computeSpectralCentroid() const {
+    float sum = 0.0f;
+    float weightedSum = 0.0f;
+    const float binToFreq = static_cast<float>(config_.sampleRate) / config_.fftLength;
+
+    for (int i = 0; i < numBins_; ++i) {
+        float freq = i * binToFreq;
+        weightedSum += freq * magnitudeSpectrum_[i];
+        sum += magnitudeSpectrum_[i];
+    }
+
+    return sum > 0.0f ? weightedSum / sum : 0.0f;
+}
+
+float AudioFeaturesProcessor::computeSpectralFlatness() const {
+    const float eps = 1e-10f;
+    float sumLog = 0.0f;
+    float sum = 0.0f;
+
+    for (int i = 0; i < numBins_; ++i) {
+        sumLog += std::log(powerSpectrum_[i] + eps);
+        sum += powerSpectrum_[i];
+    }
+
+    float geometricMean = std::exp(sumLog / numBins_);
+    float arithmeticMean = sum / numBins_;
+
+    return arithmeticMean > 0.0f ? geometricMean / arithmeticMean : 0.0f;
+}
+
+float AudioFeaturesProcessor::computeSpectralRolloff() const {
+    float totalEnergy = 0.0f;
+    for (int i = 0; i < numBins_; ++i) {
+        totalEnergy += magnitudeSpectrum_[i];
+    }
+
+    const float threshold = totalEnergy * 0.85f;
+    float cumulativeEnergy = 0.0f;
+    const float binToFreq = static_cast<float>(config_.sampleRate) / config_.fftLength;
+
+    for (int i = 0; i < numBins_; ++i) {
+        cumulativeEnergy += magnitudeSpectrum_[i];
+        if (cumulativeEnergy >= threshold) {
+            return i * binToFreq;
+        }
+    }
+
+    return 0.0f;
+}
+
+float AudioFeaturesProcessor::computeSpectralBandwidth(float centroid) const {
+    float sum = 0.0f;
+    float weightedSum = 0.0f;
+    const float binToFreq = static_cast<float>(config_.sampleRate) / config_.fftLength;
+
+    for (int i = 0; i < numBins_; ++i) {
+        float freq = i * binToFreq;
+        float diff = freq - centroid;
+        weightedSum += magnitudeSpectrum_[i] * diff * diff;
+        sum += magnitudeSpectrum_[i];
+    }
+
+    return sum > 0.0f ? std::sqrt(weightedSum / sum) : 0.0f;
+}
+
+void AudioFeaturesProcessor::computeMFCC(std::vector<float>& mfcc) const {
+    const int N = config_.nMelFilters;
+    const int K = config_.nMfcc;
+    mfcc.resize(K);
+
+    // Apply mel filterbank to power spectrum -> log mel energies
+    std::vector<float> logMelEnergies(N);
+    for (int m = 0; m < N; ++m) {
+        const MelFilter& filter = melFilters_[m];
+        const int count = static_cast<int>(filter.weights.size());
+        float energy = 0.0f;
+        const float* w = filter.weights.data();
+        const float* p = powerSpectrum_.data() + filter.startBin;
+        for (int k = 0; k < count; ++k) {
+            energy += p[k] * w[k];
+        }
+        logMelEnergies[m] = std::log(std::max(energy, 1e-10f));
+    }
+
+    // Apply precomputed DCT matrix
+    for (int i = 0; i < K; ++i) {
+        float sum = 0.0f;
+        const float* dctRow = dctMatrix_.data() + i * N;
+        for (int j = 0; j < N; ++j) {
+            sum += logMelEnergies[j] * dctRow[j];
+        }
+        mfcc[i] = sum;
+    }
+}
+
+void AudioFeaturesProcessor::computeChromagram(std::vector<float>& chroma) const {
+    chroma.assign(12, 0.0f);
+    const float binToFreq = static_cast<float>(config_.sampleRate) / config_.fftLength;
+
+    for (int i = 1; i < numBins_; ++i) {  // skip DC bin
+        float freq = i * binToFreq;
+        if (freq < 20.0f) continue;  // skip sub-audible frequencies
+
+        // Map frequency to pitch class: MIDI note = 69 + 12*log2(freq/440)
+        float midiNote = 69.0f + 12.0f * std::log2(freq / 440.0f);
+        int pitchClass = static_cast<int>(std::round(midiNote)) % 12;
+        if (pitchClass < 0) pitchClass += 12;
+
+        chroma[pitchClass] += magnitudeSpectrum_[i];
+    }
+}
+
+AudioFeaturesResult AudioFeaturesProcessor::compute(const float* samples, int numSamples) {
+    AudioFeaturesResult result;
+
+    // Single FFT pass for all features
+    computeFFT(samples, numSamples);
+
+    // Spectral features (always computed)
+    result.spectralCentroid = computeSpectralCentroid();
+    result.spectralFlatness = computeSpectralFlatness();
+    result.spectralRolloff = computeSpectralRolloff();
+    result.spectralBandwidth = computeSpectralBandwidth(result.spectralCentroid);
+
+    // MFCC (optional)
+    if (config_.computeMfcc) {
+        computeMFCC(result.mfcc);
+    }
+
+    // Chromagram (optional)
+    if (config_.computeChroma) {
+        computeChromagram(result.chromagram);
+    }
+
+    return result;
+}

package/cpp/AudioFeatures.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include "kiss_fft/kiss_fft.h"
+#include "kiss_fft/kiss_fftr.h"
+
+struct AudioFeaturesConfig {
+    int sampleRate;
+    int fftLength = 1024;
+    int nMfcc = 13;           // Number of MFCC coefficients to output
+    int nMelFilters = 26;     // Number of mel filters for MFCC
+    bool computeMfcc = true;
+    bool computeChroma = true;
+
+    bool operator==(const AudioFeaturesConfig& other) const {
+        return sampleRate == other.sampleRate &&
+               fftLength == other.fftLength &&
+               nMfcc == other.nMfcc &&
+               nMelFilters == other.nMelFilters &&
+               computeMfcc == other.computeMfcc &&
+               computeChroma == other.computeChroma;
+    }
+};
+
+struct AudioFeaturesResult {
+    float spectralCentroid;
+    float spectralFlatness;
+    float spectralRolloff;
+    float spectralBandwidth;
+    std::vector<float> mfcc;       // nMfcc coefficients
+    std::vector<float> chromagram;  // 12 bins
+};
+
+class AudioFeaturesProcessor {
+public:
+    AudioFeaturesProcessor(const AudioFeaturesConfig& config);
+    ~AudioFeaturesProcessor();
+
+    // Non-copyable (owns FFT plan)
+    AudioFeaturesProcessor(const AudioFeaturesProcessor&) = delete;
+    AudioFeaturesProcessor& operator=(const AudioFeaturesProcessor&) = delete;
+
+    AudioFeaturesResult compute(const float* samples, int numSamples);
+
+    const AudioFeaturesConfig& config() const { return config_; }
+
+private:
+    AudioFeaturesConfig config_;
+    int numBins_;  // fftLength / 2 + 1
+
+    // FFT resources
+    kiss_fftr_cfg fftCfg_;
+    std::vector<float> window_;
+    std::vector<float> fftInput_;
+    std::vector<kiss_fft_cpx> fftOutput_;
+    std::vector<float> magnitudeSpectrum_;
+    std::vector<float> powerSpectrum_;
+
+    // Mel filterbank for MFCC (sparse, same pattern as MelSpectrogram)
+    struct MelFilter {
+        int startBin;
+        std::vector<float> weights;
+    };
+    std::vector<MelFilter> melFilters_;
+
+    // DCT matrix for MFCC (precomputed)
+    std::vector<float> dctMatrix_;  // [nMfcc * nMelFilters]
+
+    void buildWindow();
+    void buildMelFilterbank();
+    void buildDCTMatrix();
+    void allocateBuffers();
+
+    void computeFFT(const float* samples, int numSamples);
+    float computeSpectralCentroid() const;
+    float computeSpectralFlatness() const;
+    float computeSpectralRolloff() const;
+    float computeSpectralBandwidth(float centroid) const;
+    void computeMFCC(std::vector<float>& mfcc) const;
+    void computeChromagram(std::vector<float>& chroma) const;
+
+    static float hzToMel(float hz);
+    static float melToHz(float mel);
+};