@siteed/expo-audio-stream 1.1.1 → 1.1.3

package/build/utils/getWavFileInfo.d.ts

@@ -0,0 +1,26 @@
+import { BitDepth, SampleRate } from '../ExpoAudioStream.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/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,0BAA0B,CAAA;AAoB/D;;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,gBACV,WAAW,KACzB,OAAO,CAAC,WAAW,CAmFrB,CAAA"}

package/build/utils/getWavFileInfo.js

@@ -0,0 +1,92 @@
+// packages/expo-audio-stream/src/utils/getWavFileInfo.ts
+import { DATA_CHUNK_ID, DEFAULT_BIT_DEPTH, DEFAULT_SAMPLE_RATE, FMT_CHUNK_ID, INFO_CHUNK_ID, RIFF_HEADER, WAVE_HEADER, } from '../constants';
+// Audio format descriptions
+const AUDIO_FORMATS = {
+    1: 'PCM',
+    3: 'IEEE float',
+    6: '8-bit ITU-T G.711 A-law',
+    7: '8-bit ITU-T G.711 µ-law',
+    65534: 'WAVE_FORMAT_EXTENSIBLE',
+};
+/**
+ * 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 const getWavFileInfo = async (arrayBuffer) => {
+    const view = new DataView(arrayBuffer);
+    // Check if the file is a valid RIFF/WAVE file
+    const riffHeader = view.getUint32(0, false);
+    const waveHeader = view.getUint32(8, false);
+    if (riffHeader !== RIFF_HEADER || waveHeader !== WAVE_HEADER) {
+        throw new Error('Invalid WAV file');
+    }
+    // Initialize variables for the metadata
+    let fmtChunkOffset = 12;
+    let sampleRate = DEFAULT_SAMPLE_RATE;
+    let numChannels = 0;
+    let bitDepth = DEFAULT_BIT_DEPTH;
+    let dataChunkSize = 0;
+    let audioFormat = 0;
+    let byteRate = 0;
+    let blockAlign = 0;
+    let creationDateTime = '';
+    let comments = '';
+    let dataChunkOffset = 0;
+    // Parse chunks to find the "fmt " and "data" chunks
+    while (fmtChunkOffset < view.byteLength) {
+        const chunkId = view.getUint32(fmtChunkOffset, false);
+        const chunkSize = view.getUint32(fmtChunkOffset + 4, true);
+        if (chunkId === FMT_CHUNK_ID) {
+            // "fmt "
+            audioFormat = view.getUint16(fmtChunkOffset + 8, true);
+            if (!AUDIO_FORMATS[audioFormat]) {
+                throw new Error('Unsupported WAV file format');
+            }
+            numChannels = view.getUint16(fmtChunkOffset + 10, true);
+            sampleRate = view.getUint32(fmtChunkOffset + 12, true);
+            byteRate = view.getUint32(fmtChunkOffset + 16, true);
+            blockAlign = view.getUint16(fmtChunkOffset + 20, true);
+            bitDepth = view.getUint16(fmtChunkOffset + 22, true);
+        }
+        else if (chunkId === DATA_CHUNK_ID) {
+            // "data"
+            dataChunkSize = chunkSize;
+            dataChunkOffset = fmtChunkOffset + 8; // Position after chunk header
+            break;
+        }
+        else if (chunkId === INFO_CHUNK_ID) {
+            // "INFO"
+            // Read INFO chunk (assuming it contains a text-based creation date/time and comments)
+            const infoStart = fmtChunkOffset + 8;
+            const infoText = new TextDecoder().decode(new Uint8Array(arrayBuffer.slice(infoStart, infoStart + chunkSize)));
+            const infoParts = infoText.split('\0');
+            creationDateTime = infoParts[0];
+            comments = infoParts[1];
+        }
+        fmtChunkOffset += 8 + chunkSize;
+    }
+    if (!sampleRate || !numChannels || !bitDepth || !dataChunkSize) {
+        throw new Error('Incomplete WAV file information');
+    }
+    // Calculate duration
+    const bytesPerSample = bitDepth / 8;
+    const numSamples = dataChunkSize / (numChannels * bytesPerSample);
+    const durationMs = (numSamples / sampleRate) * 1000;
+    return {
+        sampleRate,
+        numChannels,
+        bitDepth,
+        size: arrayBuffer.byteLength,
+        durationMs,
+        audioFormatDescription: AUDIO_FORMATS[audioFormat],
+        byteRate,
+        blockAlign,
+        creationDateTime: creationDateTime || undefined,
+        comments: comments || undefined,
+        compressionType: audioFormat === 1 ? 'None' : AUDIO_FORMATS[audioFormat],
+        dataChunkOffset,
+    };
+};
+//# sourceMappingURL=getWavFileInfo.js.map

package/build/utils/getWavFileInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWavFileInfo.js","sourceRoot":"","sources":["../../src/utils/getWavFileInfo.ts"],"names":[],"mappings":"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","sourcesContent":["// packages/expo-audio-stream/src/utils/getWavFileInfo.ts\n\nimport { BitDepth, SampleRate } from '../ExpoAudioStream.types'\nimport {\n    DATA_CHUNK_ID,\n    DEFAULT_BIT_DEPTH,\n    DEFAULT_SAMPLE_RATE,\n    FMT_CHUNK_ID,\n    INFO_CHUNK_ID,\n    RIFF_HEADER,\n    WAVE_HEADER,\n} from '../constants'\n\n// Audio format descriptions\nconst AUDIO_FORMATS: { [key: number]: string } = {\n    1: 'PCM',\n    3: 'IEEE float',\n    6: '8-bit ITU-T G.711 A-law',\n    7: '8-bit ITU-T G.711 µ-law',\n    65534: 'WAVE_FORMAT_EXTENSIBLE',\n}\n\n/**\n * Interface representing the metadata of a WAV file.\n */\nexport interface WavFileInfo {\n    sampleRate: SampleRate\n    numChannels: number\n    bitDepth: BitDepth\n    size: number // in bytes\n    durationMs: number // in ms\n    audioFormatDescription: string // Description of the audio format\n    byteRate: number // Average bytes per second\n    blockAlign: number // Number of bytes for one sample including all channels\n    creationDateTime?: string // Optional creation date and time\n    comments?: string // Optional comments or tags\n    compressionType?: string // Optional compression type\n    dataChunkOffset: number // Position of the first data chunk\n}\n\n/**\n * Extracts metadata from a WAV buffer.\n *\n * @param arrayBuffer - The array buffer containing the WAV data.\n * @returns A promise that resolves to the extracted metadata.\n */\nexport const getWavFileInfo = async (\n    arrayBuffer: ArrayBuffer\n): Promise<WavFileInfo> => {\n    const view = new DataView(arrayBuffer)\n\n    // Check if the file is a valid RIFF/WAVE file\n    const riffHeader = view.getUint32(0, false)\n    const waveHeader = view.getUint32(8, false)\n    if (riffHeader !== RIFF_HEADER || waveHeader !== WAVE_HEADER) {\n        throw new Error('Invalid WAV file')\n    }\n\n    // Initialize variables for the metadata\n    let fmtChunkOffset = 12\n    let sampleRate: SampleRate = DEFAULT_SAMPLE_RATE\n    let numChannels = 0\n    let bitDepth: BitDepth = DEFAULT_BIT_DEPTH\n    let dataChunkSize = 0\n    let audioFormat = 0\n    let byteRate = 0\n    let blockAlign = 0\n    let creationDateTime = ''\n    let comments = ''\n    let dataChunkOffset = 0\n\n    // Parse chunks to find the \"fmt \" and \"data\" chunks\n    while (fmtChunkOffset < view.byteLength) {\n        const chunkId = view.getUint32(fmtChunkOffset, false)\n        const chunkSize = view.getUint32(fmtChunkOffset + 4, true)\n        if (chunkId === FMT_CHUNK_ID) {\n            // \"fmt \"\n            audioFormat = view.getUint16(fmtChunkOffset + 8, true)\n            if (!AUDIO_FORMATS[audioFormat]) {\n                throw new Error('Unsupported WAV file format')\n            }\n            numChannels = view.getUint16(fmtChunkOffset + 10, true)\n            sampleRate = view.getUint32(fmtChunkOffset + 12, true) as SampleRate\n            byteRate = view.getUint32(fmtChunkOffset + 16, true)\n            blockAlign = view.getUint16(fmtChunkOffset + 20, true)\n            bitDepth = view.getUint16(fmtChunkOffset + 22, true) as BitDepth\n        } else if (chunkId === DATA_CHUNK_ID) {\n            // \"data\"\n            dataChunkSize = chunkSize\n            dataChunkOffset = fmtChunkOffset + 8 // Position after chunk header\n            break\n        } else if (chunkId === INFO_CHUNK_ID) {\n            // \"INFO\"\n            // Read INFO chunk (assuming it contains a text-based creation date/time and comments)\n            const infoStart = fmtChunkOffset + 8\n            const infoText = new TextDecoder().decode(\n                new Uint8Array(\n                    arrayBuffer.slice(infoStart, infoStart + chunkSize)\n                )\n            )\n            const infoParts = infoText.split('\\0')\n            creationDateTime = infoParts[0]\n            comments = infoParts[1]\n        }\n        fmtChunkOffset += 8 + chunkSize\n    }\n\n    if (!sampleRate || !numChannels || !bitDepth || !dataChunkSize) {\n        throw new Error('Incomplete WAV file information')\n    }\n\n    // Calculate duration\n    const bytesPerSample = bitDepth / 8\n    const numSamples = dataChunkSize / (numChannels * bytesPerSample)\n    const durationMs = (numSamples / sampleRate) * 1000\n\n    return {\n        sampleRate,\n        numChannels,\n        bitDepth,\n        size: arrayBuffer.byteLength,\n        durationMs,\n        audioFormatDescription: AUDIO_FORMATS[audioFormat],\n        byteRate,\n        blockAlign,\n        creationDateTime: creationDateTime || undefined,\n        comments: comments || undefined,\n        compressionType:\n            audioFormat === 1 ? 'None' : AUDIO_FORMATS[audioFormat],\n        dataChunkOffset,\n    }\n}\n"]}

package/build/utils/writeWavHeader.d.ts

@@ -0,0 +1,9 @@
+interface WavHeaderOptions {
+    buffer: ArrayBuffer;
+    sampleRate: number;
+    numChannels: number;
+    bitDepth: number;
+}
+export declare const writeWavHeader: ({ buffer, sampleRate, numChannels, bitDepth, }: WavHeaderOptions) => ArrayBuffer;
+export {};
+//# sourceMappingURL=writeWavHeader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeWavHeader.d.ts","sourceRoot":"","sources":["../../src/utils/writeWavHeader.ts"],"names":[],"mappings":"AACA,UAAU,gBAAgB;IACtB,MAAM,EAAE,WAAW,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,eAAO,MAAM,cAAc,mDAKxB,gBAAgB,KAAG,WA+CrB,CAAA"}

package/build/utils/writeWavHeader.js

@@ -0,0 +1,45 @@
+export const writeWavHeader = ({ buffer, sampleRate, numChannels, bitDepth, }) => {
+    const bytesPerSample = bitDepth / 8;
+    const numSamples = buffer.byteLength / (numChannels * bytesPerSample);
+    const view = new DataView(buffer);
+    const blockAlign = numChannels * bytesPerSample;
+    const byteRate = sampleRate * blockAlign;
+    // Function to write a string to the DataView
+    const writeString = (view, offset, string) => {
+        for (let i = 0; i < string.length; i++) {
+            view.setUint8(offset + i, string.charCodeAt(i));
+        }
+    };
+    // 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) {
+        // Ensure the buffer is large enough for the WAV header
+        if (buffer.byteLength < 44) {
+            throw new Error('Buffer is too small to contain a valid WAV header');
+        }
+        // Write the WAV header
+        writeString(view, 0, 'RIFF'); // ChunkID
+        view.setUint32(4, 36 + numSamples * blockAlign, true); // ChunkSize
+        writeString(view, 8, 'WAVE'); // Format
+        writeString(view, 12, 'fmt '); // Subchunk1ID
+        view.setUint32(16, 16, true); // Subchunk1Size (16 for PCM)
+        view.setUint16(20, bitDepth === 32 ? 3 : 1, 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
+        view.setUint16(32, blockAlign, true); // BlockAlign
+        view.setUint16(34, bitDepth, true); // BitsPerSample
+        writeString(view, 36, 'data'); // Subchunk2ID
+        view.setUint32(40, numSamples * blockAlign, true); // Subchunk2Size
+    }
+    else {
+        // Update the existing WAV header if necessary
+        view.setUint32(4, 36 + numSamples * blockAlign, true); // Update ChunkSize
+        view.setUint32(24, sampleRate, true); // Update SampleRate
+        view.setUint32(28, byteRate, true); // Update ByteRate
+        view.setUint16(32, blockAlign, true); // Update BlockAlign
+        view.setUint32(40, numSamples * blockAlign, true); // Update Subchunk2Size
+    }
+    return buffer;
+};
+//# sourceMappingURL=writeWavHeader.js.map

package/build/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/expo-audio-stream/src/utils/writeWavHeader.ts\ninterface WavHeaderOptions {\n    buffer: ArrayBuffer\n    sampleRate: number\n    numChannels: number\n    bitDepth: number\n}\n\nexport const writeWavHeader = ({\n    buffer,\n    sampleRate,\n    numChannels,\n    bitDepth,\n}: WavHeaderOptions): ArrayBuffer => {\n    const bytesPerSample = bitDepth / 8\n    const numSamples = buffer.byteLength / (numChannels * bytesPerSample)\n    const view = new DataView(buffer)\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    // 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        // Ensure the buffer is large enough for the WAV header\n        if (buffer.byteLength < 44) {\n            throw new Error('Buffer is too small to contain a valid WAV header')\n        }\n\n        // Write the WAV header\n        writeString(view, 0, 'RIFF') // ChunkID\n        view.setUint32(4, 36 + numSamples * blockAlign, true) // ChunkSize\n        writeString(view, 8, 'WAVE') // Format\n        writeString(view, 12, 'fmt ') // Subchunk1ID\n        view.setUint32(16, 16, true) // Subchunk1Size (16 for PCM)\n        view.setUint16(20, bitDepth === 32 ? 3 : 1, 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\n        view.setUint16(32, blockAlign, true) // BlockAlign\n        view.setUint16(34, bitDepth, true) // BitsPerSample\n        writeString(view, 36, 'data') // Subchunk2ID\n        view.setUint32(40, numSamples * blockAlign, true) // Subchunk2Size\n    } else {\n        // Update the existing WAV header if necessary\n        view.setUint32(4, 36 + numSamples * blockAlign, true) // Update ChunkSize\n        view.setUint32(24, sampleRate, true) // Update SampleRate\n        view.setUint32(28, byteRate, true) // Update ByteRate\n        view.setUint16(32, blockAlign, true) // Update BlockAlign\n        view.setUint32(40, numSamples * blockAlign, true) // Update Subchunk2Size\n    }\n\n    return buffer\n}\n"]}

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

@@ -0,0 +1,2 @@
+export declare const InlineFeaturesExtractor = "\n// Unique ID counter\nlet uniqueIdCounter = 0\n\nself.onmessage = function (event) {\n    const {\n        channelData, // this is only the newly recorded data when live recording.\n        sampleRate,\n        pointsPerSecond,\n        algorithm,\n        bitDepth,\n        fullAudioDurationMs,\n        numberOfChannels,\n        features: _features,\n    } = event.data\n\n    console.log('[AudioFeaturesExtractor] Worker received message', event.data)\n    const features = _features || {}\n\n    const SILENCE_THRESHOLD = 0.01\n    const MIN_SILENCE_DURATION = 1.5 * sampleRate // 1.5 seconds of silence\n    const SPEECH_INERTIA_DURATION = 0.1 * sampleRate // Speech inertia duration in samples\n    const RMS_THRESHOLD = 0.01\n    const ZCR_THRESHOLD = 0.1\n\n    // Placeholder functions for feature extraction\n    const extractMFCC = (segmentData, sampleRate) => {\n        // Implement MFCC extraction logic here\n        return []\n    }\n\n    const extractSpectralCentroid = (segmentData, sampleRate) => {\n        const magnitudeSpectrum = segmentData.map((v) => v * v)\n        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        if (sum === 0) return 0\n\n        const weightedSum = magnitudeSpectrum.reduce(\n            (acc, value, index) => acc + index * value,\n            0\n        )\n        return (\n            ((weightedSum / sum) * (sampleRate / 2)) / magnitudeSpectrum.length\n        )\n    }\n\n    const extractSpectralFlatness = (segmentData) => {\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const geometricMean = Math.exp(\n            magnitudeSpectrum\n                .map((v) => Math.log(v + Number.MIN_VALUE))\n                .reduce((a, b) => a + b) / magnitudeSpectrum.length\n        )\n        const arithmeticMean =\n            magnitudeSpectrum.reduce((a, b) => a + b) / magnitudeSpectrum.length\n        return arithmeticMean === 0 ? 0 : geometricMean / arithmeticMean\n    }\n\n    const extractSpectralRollOff = (segmentData, sampleRate) => {\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const totalEnergy = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        const rollOffThreshold = totalEnergy * 0.85\n        let cumulativeEnergy = 0\n\n        for (let i = 0; i < magnitudeSpectrum.length; i++) {\n            cumulativeEnergy += magnitudeSpectrum[i]\n            if (cumulativeEnergy >= rollOffThreshold) {\n                return (i / magnitudeSpectrum.length) * (sampleRate / 2)\n            }\n        }\n\n        return 0\n    }\n\n    const extractSpectralBandwidth = (segmentData, sampleRate) => {\n        const centroid = extractSpectralCentroid(segmentData, sampleRate)\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        if (sum === 0) return 0\n\n        const weightedSum = magnitudeSpectrum.reduce(\n            (acc, value, index) => acc + value * Math.pow(index - centroid, 2),\n            0\n        )\n        return Math.sqrt(weightedSum / sum)\n    }\n\n    const extractChromagram = (segmentData, sampleRate) => {\n        return [] // TODO implement\n    }\n\n    const extractHNR = (segmentData) => {\n        const frameSize = segmentData.length\n        const autocorrelation = new Float32Array(frameSize)\n\n        // Compute the autocorrelation of the segment data\n        for (let i = 0; i < frameSize; i++) {\n            let sum = 0\n            for (let j = 0; j < frameSize - i; j++) {\n                sum += segmentData[j] * segmentData[j + i]\n            }\n            autocorrelation[i] = sum\n        }\n\n        // Find the maximum autocorrelation value (excluding the zero lag)\n        const maxAutocorrelation = Math.max(...autocorrelation.subarray(1))\n\n        // Compute the HNR\n        return autocorrelation[0] !== 0\n            ? 10 *\n                  Math.log10(\n                      maxAutocorrelation /\n                          (autocorrelation[0] - maxAutocorrelation)\n                  )\n            : 0\n    }\n\n    const extractWaveform = (\n        channelData, // Float32Array\n        sampleRate, // number\n        pointsPerSecond, // number\n        algorithm // string\n    ) => {\n        const totalSamples = channelData.length\n        const segmentDuration = totalSamples / sampleRate\n        const totalPoints = Math.max(\n            Math.ceil(segmentDuration * pointsPerSecond),\n            1\n        )\n        const pointInterval = Math.ceil(totalSamples / totalPoints)\n        const dataPoints = []\n        let minAmplitude = Infinity\n        let maxAmplitude = -Infinity\n        let silenceStart = null\n        let lastSpeechEnd = -Infinity\n        let isSpeech = false\n\n        const expectedPoints = segmentDuration * pointsPerSecond\n        const samplesPerPoint = Math.ceil(channelData.length / expectedPoints)\n\n        for (let i = 0; i < expectedPoints; i++) {\n            const start = i * samplesPerPoint\n            const end = Math.min(start + samplesPerPoint, totalSamples)\n\n            let sumSquares = 0\n            let zeroCrossings = 0\n            let prevValue = channelData[start]\n            let localMinAmplitude = Infinity\n            let localMaxAmplitude = -Infinity\n            let hasNonZeroValue = false\n\n            // compute values for the segment\n            for (let j = start; j < end; j++) {\n                const value = channelData[j]\n                sumSquares += value * value\n                if (j > start && value * prevValue < 0) {\n                    zeroCrossings++\n                }\n                prevValue = value\n\n                // We need to keep absolute value otherwise we cannot visualize properly\n                const absValue = Math.abs(value)\n                localMinAmplitude = Math.min(localMinAmplitude, absValue)\n                localMaxAmplitude = Math.max(localMaxAmplitude, absValue)\n\n                if (value !== 0) {\n                    hasNonZeroValue = true\n                }\n            }\n\n            // Post-processing checks\n            if (!hasNonZeroValue) {\n                // All values are zero\n                localMinAmplitude = 0\n                localMaxAmplitude = 0\n            }\n\n            const rms = Math.sqrt(sumSquares / (end - start))\n            minAmplitude = Math.min(minAmplitude, localMinAmplitude)\n            maxAmplitude = Math.max(maxAmplitude, localMaxAmplitude)\n\n            const energy = sumSquares\n            const zcr = zeroCrossings / (end - start)\n\n            const silent = rms < SILENCE_THRESHOLD\n            const dB = 20 * Math.log10(rms)\n\n            if (silent) {\n                if (silenceStart === null) {\n                    silenceStart = start\n                } else if (start - silenceStart > MIN_SILENCE_DURATION) {\n                    // Silence detected for longer than the threshold, set amplitude to 0\n                    localMaxAmplitude = 0\n                    localMinAmplitude = 0\n                    isSpeech = false\n                }\n            } else {\n                silenceStart = null\n                if (\n                    !isSpeech &&\n                    start - lastSpeechEnd < SPEECH_INERTIA_DURATION\n                ) {\n                    isSpeech = true\n                }\n                lastSpeechEnd = end\n            }\n\n            const activeSpeech =\n                (rms > RMS_THRESHOLD && zcr > ZCR_THRESHOLD) ||\n                (isSpeech && start - lastSpeechEnd < SPEECH_INERTIA_DURATION)\n\n            if (activeSpeech) {\n                isSpeech = true\n                lastSpeechEnd = end\n            } else {\n                isSpeech = false\n            }\n\n            const bytesPerSample = bitDepth / 8\n            const startPosition = start * bytesPerSample * numberOfChannels // Calculate start position in bytes\n            const endPosition = end * bytesPerSample * numberOfChannels // Calculate end position in bytes\n\n            // Compute features\n            const segmentData = channelData.slice(start, end)\n            const mfcc = features.mfcc\n                ? extractMFCC(segmentData, sampleRate)\n                : []\n            const spectralCentroid = features.spectralCentroid\n                ? extractSpectralCentroid(segmentData, sampleRate)\n                : 0\n            const spectralFlatness = features.spectralFlatness\n                ? extractSpectralFlatness(segmentData)\n                : 0\n            const spectralRollOff = features.spectralRollOff\n                ? extractSpectralRollOff(segmentData, sampleRate)\n                : 0\n            const spectralBandwidth = features.spectralBandwidth\n                ? extractSpectralBandwidth(segmentData, sampleRate)\n                : 0\n            const chromagram = features.chromagram\n                ? extractChromagram(segmentData, sampleRate)\n                : []\n            const hnr = features.hnr ? extractHNR(segmentData) : 0\n\n            const peakAmp = Math.max(Math.abs(localMaxAmplitude), Math.abs(localMinAmplitude))\n            const newData = {\n                id: uniqueIdCounter++, // Assign unique ID and increment the counter\n                amplitude: algorithm === 'peak' ? peakAmp : rms,\n                activeSpeech,\n                dB,\n                silent,\n                features: {\n                    energy,\n                    rms,\n                    minAmplitude: localMinAmplitude,\n                    maxAmplitude: localMaxAmplitude,\n                    zcr,\n                    mfcc: [], // Placeholder for MFCC features\n                    spectralCentroid, // Computed spectral centroid\n                    spectralFlatness, // Computed spectral flatness\n                    spectralRollOff, // Computed spectral roll-off\n                    spectralBandwidth, // Computed spectral bandwidth\n                    chromagram, // Computed chromagram\n                    hnr, // Computed HNR\n                },\n                startTime: start / sampleRate,\n                endTime: end / sampleRate,\n                startPosition,\n                endPosition,\n                samples: end - start,\n                speaker: 0, // Assuming speaker detection is to be handled later\n            }\n\n            dataPoints.push(newData)\n        }\n\n        return {\n            pointsPerSecond,\n            amplitudeAlgorithm: algorithm,\n            durationMs: fullAudioDurationMs,\n            bitDepth,\n            samples: totalSamples,\n            numberOfChannels,\n            sampleRate,\n            dataPoints,\n            amplitudeRange: {\n                min: minAmplitude,\n                max: maxAmplitude,\n            },\n            speakerChanges: [], // Placeholder for future speaker detection logic\n        }\n    }\n\n    try {\n        const result = extractWaveform(\n            channelData,\n            sampleRate,\n            pointsPerSecond,\n            algorithm\n        )\n        self.postMessage({\n            command: 'features',\n            result,\n        })\n    } catch (error) {\n        console.error('[AudioFeaturesExtractor] Error in processing', error)\n        self.postMessage({ error: error.message })\n    } finally {\n        // Do not close the worker so it can be re-used for subsequent messages\n        // self.close();\n    }\n}\n";
+//# sourceMappingURL=InlineFeaturesExtractor.web.d.ts.map

package/build/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":"AAAA,eAAO,MAAM,uBAAuB,4yWAuTnC,CAAA"}

package/{src/workers/InlineFeaturesExtractor.web.tsx → build/workers/InlineFeaturesExtractor.web.js}

@@ -309,4 +309,5 @@ self.onmessage = function (event) {
         // self.close();
     }
 }
-`
+`;
+//# sourceMappingURL=InlineFeaturesExtractor.web.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InlineFeaturesExtractor.web.js","sourceRoot":"","sources":["../../src/workers/InlineFeaturesExtractor.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuTtC,CAAA","sourcesContent":["export const InlineFeaturesExtractor = `\n// Unique ID counter\nlet uniqueIdCounter = 0\n\nself.onmessage = function (event) {\n    const {\n        channelData, // this is only the newly recorded data when live recording.\n        sampleRate,\n        pointsPerSecond,\n        algorithm,\n        bitDepth,\n        fullAudioDurationMs,\n        numberOfChannels,\n        features: _features,\n    } = event.data\n\n    console.log('[AudioFeaturesExtractor] Worker received message', event.data)\n    const features = _features || {}\n\n    const SILENCE_THRESHOLD = 0.01\n    const MIN_SILENCE_DURATION = 1.5 * sampleRate // 1.5 seconds of silence\n    const SPEECH_INERTIA_DURATION = 0.1 * sampleRate // Speech inertia duration in samples\n    const RMS_THRESHOLD = 0.01\n    const ZCR_THRESHOLD = 0.1\n\n    // Placeholder functions for feature extraction\n    const extractMFCC = (segmentData, sampleRate) => {\n        // Implement MFCC extraction logic here\n        return []\n    }\n\n    const extractSpectralCentroid = (segmentData, sampleRate) => {\n        const magnitudeSpectrum = segmentData.map((v) => v * v)\n        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        if (sum === 0) return 0\n\n        const weightedSum = magnitudeSpectrum.reduce(\n            (acc, value, index) => acc + index * value,\n            0\n        )\n        return (\n            ((weightedSum / sum) * (sampleRate / 2)) / magnitudeSpectrum.length\n        )\n    }\n\n    const extractSpectralFlatness = (segmentData) => {\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const geometricMean = Math.exp(\n            magnitudeSpectrum\n                .map((v) => Math.log(v + Number.MIN_VALUE))\n                .reduce((a, b) => a + b) / magnitudeSpectrum.length\n        )\n        const arithmeticMean =\n            magnitudeSpectrum.reduce((a, b) => a + b) / magnitudeSpectrum.length\n        return arithmeticMean === 0 ? 0 : geometricMean / arithmeticMean\n    }\n\n    const extractSpectralRollOff = (segmentData, sampleRate) => {\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const totalEnergy = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        const rollOffThreshold = totalEnergy * 0.85\n        let cumulativeEnergy = 0\n\n        for (let i = 0; i < magnitudeSpectrum.length; i++) {\n            cumulativeEnergy += magnitudeSpectrum[i]\n            if (cumulativeEnergy >= rollOffThreshold) {\n                return (i / magnitudeSpectrum.length) * (sampleRate / 2)\n            }\n        }\n\n        return 0\n    }\n\n    const extractSpectralBandwidth = (segmentData, sampleRate) => {\n        const centroid = extractSpectralCentroid(segmentData, sampleRate)\n        const magnitudeSpectrum = segmentData.map((v) => Math.abs(v))\n        const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0)\n        if (sum === 0) return 0\n\n        const weightedSum = magnitudeSpectrum.reduce(\n            (acc, value, index) => acc + value * Math.pow(index - centroid, 2),\n            0\n        )\n        return Math.sqrt(weightedSum / sum)\n    }\n\n    const extractChromagram = (segmentData, sampleRate) => {\n        return [] // TODO implement\n    }\n\n    const extractHNR = (segmentData) => {\n        const frameSize = segmentData.length\n        const autocorrelation = new Float32Array(frameSize)\n\n        // Compute the autocorrelation of the segment data\n        for (let i = 0; i < frameSize; i++) {\n            let sum = 0\n            for (let j = 0; j < frameSize - i; j++) {\n                sum += segmentData[j] * segmentData[j + i]\n            }\n            autocorrelation[i] = sum\n        }\n\n        // Find the maximum autocorrelation value (excluding the zero lag)\n        const maxAutocorrelation = Math.max(...autocorrelation.subarray(1))\n\n        // Compute the HNR\n        return autocorrelation[0] !== 0\n            ? 10 *\n                  Math.log10(\n                      maxAutocorrelation /\n                          (autocorrelation[0] - maxAutocorrelation)\n                  )\n            : 0\n    }\n\n    const extractWaveform = (\n        channelData, // Float32Array\n        sampleRate, // number\n        pointsPerSecond, // number\n        algorithm // string\n    ) => {\n        const totalSamples = channelData.length\n        const segmentDuration = totalSamples / sampleRate\n        const totalPoints = Math.max(\n            Math.ceil(segmentDuration * pointsPerSecond),\n            1\n        )\n        const pointInterval = Math.ceil(totalSamples / totalPoints)\n        const dataPoints = []\n        let minAmplitude = Infinity\n        let maxAmplitude = -Infinity\n        let silenceStart = null\n        let lastSpeechEnd = -Infinity\n        let isSpeech = false\n\n        const expectedPoints = segmentDuration * pointsPerSecond\n        const samplesPerPoint = Math.ceil(channelData.length / expectedPoints)\n\n        for (let i = 0; i < expectedPoints; i++) {\n            const start = i * samplesPerPoint\n            const end = Math.min(start + samplesPerPoint, totalSamples)\n\n            let sumSquares = 0\n            let zeroCrossings = 0\n            let prevValue = channelData[start]\n            let localMinAmplitude = Infinity\n            let localMaxAmplitude = -Infinity\n            let hasNonZeroValue = false\n\n            // compute values for the segment\n            for (let j = start; j < end; j++) {\n                const value = channelData[j]\n                sumSquares += value * value\n                if (j > start && value * prevValue < 0) {\n                    zeroCrossings++\n                }\n                prevValue = value\n\n                // We need to keep absolute value otherwise we cannot visualize properly\n                const absValue = Math.abs(value)\n                localMinAmplitude = Math.min(localMinAmplitude, absValue)\n                localMaxAmplitude = Math.max(localMaxAmplitude, absValue)\n\n                if (value !== 0) {\n                    hasNonZeroValue = true\n                }\n            }\n\n            // Post-processing checks\n            if (!hasNonZeroValue) {\n                // All values are zero\n                localMinAmplitude = 0\n                localMaxAmplitude = 0\n            }\n\n            const rms = Math.sqrt(sumSquares / (end - start))\n            minAmplitude = Math.min(minAmplitude, localMinAmplitude)\n            maxAmplitude = Math.max(maxAmplitude, localMaxAmplitude)\n\n            const energy = sumSquares\n            const zcr = zeroCrossings / (end - start)\n\n            const silent = rms < SILENCE_THRESHOLD\n            const dB = 20 * Math.log10(rms)\n\n            if (silent) {\n                if (silenceStart === null) {\n                    silenceStart = start\n                } else if (start - silenceStart > MIN_SILENCE_DURATION) {\n                    // Silence detected for longer than the threshold, set amplitude to 0\n                    localMaxAmplitude = 0\n                    localMinAmplitude = 0\n                    isSpeech = false\n                }\n            } else {\n                silenceStart = null\n                if (\n                    !isSpeech &&\n                    start - lastSpeechEnd < SPEECH_INERTIA_DURATION\n                ) {\n                    isSpeech = true\n                }\n                lastSpeechEnd = end\n            }\n\n            const activeSpeech =\n                (rms > RMS_THRESHOLD && zcr > ZCR_THRESHOLD) ||\n                (isSpeech && start - lastSpeechEnd < SPEECH_INERTIA_DURATION)\n\n            if (activeSpeech) {\n                isSpeech = true\n                lastSpeechEnd = end\n            } else {\n                isSpeech = false\n            }\n\n            const bytesPerSample = bitDepth / 8\n            const startPosition = start * bytesPerSample * numberOfChannels // Calculate start position in bytes\n            const endPosition = end * bytesPerSample * numberOfChannels // Calculate end position in bytes\n\n            // Compute features\n            const segmentData = channelData.slice(start, end)\n            const mfcc = features.mfcc\n                ? extractMFCC(segmentData, sampleRate)\n                : []\n            const spectralCentroid = features.spectralCentroid\n                ? extractSpectralCentroid(segmentData, sampleRate)\n                : 0\n            const spectralFlatness = features.spectralFlatness\n                ? extractSpectralFlatness(segmentData)\n                : 0\n            const spectralRollOff = features.spectralRollOff\n                ? extractSpectralRollOff(segmentData, sampleRate)\n                : 0\n            const spectralBandwidth = features.spectralBandwidth\n                ? extractSpectralBandwidth(segmentData, sampleRate)\n                : 0\n            const chromagram = features.chromagram\n                ? extractChromagram(segmentData, sampleRate)\n                : []\n            const hnr = features.hnr ? extractHNR(segmentData) : 0\n\n            const peakAmp = Math.max(Math.abs(localMaxAmplitude), Math.abs(localMinAmplitude))\n            const newData = {\n                id: uniqueIdCounter++, // Assign unique ID and increment the counter\n                amplitude: algorithm === 'peak' ? peakAmp : rms,\n                activeSpeech,\n                dB,\n                silent,\n                features: {\n                    energy,\n                    rms,\n                    minAmplitude: localMinAmplitude,\n                    maxAmplitude: localMaxAmplitude,\n                    zcr,\n                    mfcc: [], // Placeholder for MFCC features\n                    spectralCentroid, // Computed spectral centroid\n                    spectralFlatness, // Computed spectral flatness\n                    spectralRollOff, // Computed spectral roll-off\n                    spectralBandwidth, // Computed spectral bandwidth\n                    chromagram, // Computed chromagram\n                    hnr, // Computed HNR\n                },\n                startTime: start / sampleRate,\n                endTime: end / sampleRate,\n                startPosition,\n                endPosition,\n                samples: end - start,\n                speaker: 0, // Assuming speaker detection is to be handled later\n            }\n\n            dataPoints.push(newData)\n        }\n\n        return {\n            pointsPerSecond,\n            amplitudeAlgorithm: algorithm,\n            durationMs: fullAudioDurationMs,\n            bitDepth,\n            samples: totalSamples,\n            numberOfChannels,\n            sampleRate,\n            dataPoints,\n            amplitudeRange: {\n                min: minAmplitude,\n                max: maxAmplitude,\n            },\n            speakerChanges: [], // Placeholder for future speaker detection logic\n        }\n    }\n\n    try {\n        const result = extractWaveform(\n            channelData,\n            sampleRate,\n            pointsPerSecond,\n            algorithm\n        )\n        self.postMessage({\n            command: 'features',\n            result,\n        })\n    } catch (error) {\n        console.error('[AudioFeaturesExtractor] Error in processing', error)\n        self.postMessage({ error: error.message })\n    } finally {\n        // Do not close the worker so it can be re-used for subsequent messages\n        // self.close();\n    }\n}\n`\n"]}

package/build/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.recordedBuffers = [] // Float32Array\n        this.newRecBuffer = [] // Float32Array\n        this.resampledBuffer = [] // Float32Array\n        this.exportIntervalSamples = 0\n        this.samplesSinceLastExport = 0\n        this.recordSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.exportSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.recordBitDepth = DEFAULT_BIT_DEPTH // Default to 32-bit depth\n        this.exportBitDepth = DEFAULT_BIT_DEPTH // To be overwritten\n        this.numberOfChannels = 1 // Default to 1 channel (mono)\n        this.isRecording = true\n        this.port.onmessage = this.handleMessage.bind(this)\n    }\n\n    handleMessage(event) {\n        switch (event.data.command) {\n            case 'init':\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 ||\n                    this.recordBitDepth ||\n                    DEFAULT_BIT_DEPTH\n                break\n            case 'stop':\n                this.isRecording = false\n                this.getAllRecordedData()\n                    .then((fullRecordedData) => {\n                        this.port.postMessage({\n                            command: 'recordedData',\n                            recordedData: fullRecordedData,\n                            bitDepth: this.exportBitDepth,\n                            sampleRate: this.exportSampleRate,\n                        })\n                        return fullRecordedData\n                    })\n                    .catch((error) => {\n                        console.error(\n                            'RecorderProcessor Error extracting recorded data:',\n                            error\n                        )\n                    })\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.newRecBuffer.push(newBuffer)\n            this.recordedBuffers.push(newBuffer)\n            this.samplesSinceLastExport += newBuffer.length\n\n            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n                this.exportNewData()\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    floatTo16BitPCM(input) {\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        console.debug(\n            'RecorderProcessor Float to 16-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    floatTo32BitPCM(input) {\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        console.debug(\n            'RecorderProcessor Float to 32-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    resample(samples, targetSampleRate) {\n        if (this.recordSampleRate === targetSampleRate) {\n            return samples\n        }\n        const resampledBuffer = new Float32Array(\n            (samples.length * targetSampleRate) / this.recordSampleRate\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] = accum / count\n            offset = nextOffset\n        }\n        return resampledBuffer\n    }\n\n    async resampleBuffer(buffer, targetSampleRate) {\n        if (typeof OfflineAudioContext === 'undefined') {\n            return this.resample(buffer, targetSampleRate)\n        }\n\n        if (this.recordSampleRate === targetSampleRate) {\n            return buffer\n        }\n        const offlineContext = new OfflineAudioContext(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        const sourceBuffer = offlineContext.createBuffer(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        sourceBuffer.copyToChannel(buffer, 0)\n\n        const bufferSource = offlineContext.createBufferSource()\n        bufferSource.buffer = sourceBuffer\n        bufferSource.connect(offlineContext.destination)\n        bufferSource.start()\n\n        const renderedBuffer = await offlineContext.startRendering()\n\n        const resampledBuffer = new Float32Array(renderedBuffer.length)\n        renderedBuffer.copyFromChannel(resampledBuffer, 0)\n\n        return resampledBuffer\n    }\n\n    async exportNewData() {\n        // Calculate the total length of the new recorded buffers\n        const length = this.newRecBuffer.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n\n        // Merge all new recorded buffers into a single buffer\n        const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length)\n\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n\n        let finalBuffer = resampledBuffer // Float32Array\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        // Clear the new recorded buffers after they have been processed\n        this.newRecBuffer.length = 0\n\n        // Post the message to the main thread\n        // The first argument is the message data, containing the encoded WAV buffer\n        // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n        // to the main thread, avoiding the need to copy the buffer and improving performance\n        // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n        this.port.postMessage(\n            {\n                command: 'newData',\n                recordedData: finalBuffer,\n                sampleRate: this.exportSampleRate,\n                bitDepth: this.exportBitDepth,\n            },\n            []\n        )\n    }\n\n    async getAllRecordedData() {\n        const length = this.recordedBuffers.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n        const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length)\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n        // Convert to the desired bit depth if necessary\n        let finalBuffer = resampledBuffer\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        this.recordedBuffers.length = 0 // Clear the buffers after extraction\n\n        return finalBuffer\n    }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor)\n";
+//# sourceMappingURL=inlineAudioWebWorker.web.d.ts.map

package/build/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":"AAAA,eAAO,MAAM,oBAAoB,urSAyPhC,CAAA"}

package/{src/workers/inlineAudioWebWorker.web.tsx → build/workers/inlineAudioWebWorker.web.js}

@@ -247,4 +247,5 @@ class RecorderProcessor extends AudioWorkletProcessor {
 }
 
 registerProcessor('recorder-processor', RecorderProcessor)
-`
+`;
+//# sourceMappingURL=inlineAudioWebWorker.web.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inlineAudioWebWorker.web.js","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyPnC,CAAA","sourcesContent":["export const InlineAudioWebWorker = `\nconst DEFAULT_BIT_DEPTH = 32\nconst DEFAULT_SAMPLE_RATE = 44100\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n    constructor() {\n        super()\n        this.recordedBuffers = [] // Float32Array\n        this.newRecBuffer = [] // Float32Array\n        this.resampledBuffer = [] // Float32Array\n        this.exportIntervalSamples = 0\n        this.samplesSinceLastExport = 0\n        this.recordSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.exportSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten\n        this.recordBitDepth = DEFAULT_BIT_DEPTH // Default to 32-bit depth\n        this.exportBitDepth = DEFAULT_BIT_DEPTH // To be overwritten\n        this.numberOfChannels = 1 // Default to 1 channel (mono)\n        this.isRecording = true\n        this.port.onmessage = this.handleMessage.bind(this)\n    }\n\n    handleMessage(event) {\n        switch (event.data.command) {\n            case 'init':\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 ||\n                    this.recordBitDepth ||\n                    DEFAULT_BIT_DEPTH\n                break\n            case 'stop':\n                this.isRecording = false\n                this.getAllRecordedData()\n                    .then((fullRecordedData) => {\n                        this.port.postMessage({\n                            command: 'recordedData',\n                            recordedData: fullRecordedData,\n                            bitDepth: this.exportBitDepth,\n                            sampleRate: this.exportSampleRate,\n                        })\n                        return fullRecordedData\n                    })\n                    .catch((error) => {\n                        console.error(\n                            'RecorderProcessor Error extracting recorded data:',\n                            error\n                        )\n                    })\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.newRecBuffer.push(newBuffer)\n            this.recordedBuffers.push(newBuffer)\n            this.samplesSinceLastExport += newBuffer.length\n\n            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n                this.exportNewData()\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    floatTo16BitPCM(input) {\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        console.debug(\n            'RecorderProcessor Float to 16-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    floatTo32BitPCM(input) {\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        console.debug(\n            'RecorderProcessor Float to 32-bit PCM conversion complete. Output byte length:',\n            output.byteLength\n        )\n        return output\n    }\n\n    resample(samples, targetSampleRate) {\n        if (this.recordSampleRate === targetSampleRate) {\n            return samples\n        }\n        const resampledBuffer = new Float32Array(\n            (samples.length * targetSampleRate) / this.recordSampleRate\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] = accum / count\n            offset = nextOffset\n        }\n        return resampledBuffer\n    }\n\n    async resampleBuffer(buffer, targetSampleRate) {\n        if (typeof OfflineAudioContext === 'undefined') {\n            return this.resample(buffer, targetSampleRate)\n        }\n\n        if (this.recordSampleRate === targetSampleRate) {\n            return buffer\n        }\n        const offlineContext = new OfflineAudioContext(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        const sourceBuffer = offlineContext.createBuffer(\n            this.numberOfChannels,\n            buffer.length,\n            this.recordSampleRate\n        )\n        sourceBuffer.copyToChannel(buffer, 0)\n\n        const bufferSource = offlineContext.createBufferSource()\n        bufferSource.buffer = sourceBuffer\n        bufferSource.connect(offlineContext.destination)\n        bufferSource.start()\n\n        const renderedBuffer = await offlineContext.startRendering()\n\n        const resampledBuffer = new Float32Array(renderedBuffer.length)\n        renderedBuffer.copyFromChannel(resampledBuffer, 0)\n\n        return resampledBuffer\n    }\n\n    async exportNewData() {\n        // Calculate the total length of the new recorded buffers\n        const length = this.newRecBuffer.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n\n        // Merge all new recorded buffers into a single buffer\n        const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length)\n\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n\n        let finalBuffer = resampledBuffer // Float32Array\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        // Clear the new recorded buffers after they have been processed\n        this.newRecBuffer.length = 0\n\n        // Post the message to the main thread\n        // The first argument is the message data, containing the encoded WAV buffer\n        // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n        // to the main thread, avoiding the need to copy the buffer and improving performance\n        // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n        this.port.postMessage(\n            {\n                command: 'newData',\n                recordedData: finalBuffer,\n                sampleRate: this.exportSampleRate,\n                bitDepth: this.exportBitDepth,\n            },\n            []\n        )\n    }\n\n    async getAllRecordedData() {\n        const length = this.recordedBuffers.reduce(\n            (acc, buffer) => acc + buffer.length,\n            0\n        )\n        const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length)\n        const resampledBuffer = await this.resampleBuffer(\n            mergedBuffer,\n            this.exportSampleRate\n        )\n        // Convert to the desired bit depth if necessary\n        let finalBuffer = resampledBuffer\n        if (this.recordBitDepth !== this.exportBitDepth) {\n            if (this.exportBitDepth === 16) {\n                finalBuffer = this.floatTo16BitPCM(resampledBuffer)\n            } else if (this.exportBitDepth === 32) {\n                finalBuffer = this.floatTo32BitPCM(resampledBuffer)\n            }\n        }\n\n        const originalSize = mergedBuffer.byteLength\n        const resampledSize = resampledBuffer.byteLength\n        const finalSize = finalBuffer.byteLength\n\n        this.recordedBuffers.length = 0 // Clear the buffers after extraction\n\n        return finalBuffer\n    }\n}\n\nregisterProcessor('recorder-processor', RecorderProcessor)\n`\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/expo-audio-stream",
-    "version": "1.1.1",
+    "version": "1.1.3",
     "description": "stream audio crossplatform",
     "license": "MIT",
     "main": "build/index.js",
@@ -22,10 +22,10 @@
         "ExpoAudioStream"
     ],
     "files": [
-        "src",
         "android",
         "ios",
         "cpp",
+        "build",
         "generated",
         "README.md",
         "package.json",

package/src/AudioAnalysis/AudioAnalysis.types.ts

@@ -1,84 +0,0 @@
-// packages/expo-audio-stream/src/AudioAnalysis/AudioAnalysis.types.ts
-
-/**
- * Represents various audio features extracted from an audio signal.
- */
-export interface AudioFeatures {
-    energy: number // The infinite integral of the squared signal, representing the overall energy of the audio.
-    mfcc: number[] // Mel-frequency cepstral coefficients, describing the short-term power spectrum of a sound.
-    rms: number // Root mean square value, indicating the amplitude of the audio signal.
-    minAmplitude: number // Minimum amplitude value in the audio signal.
-    maxAmplitude: number // Maximum amplitude value in the audio signal.
-    zcr: number // Zero-crossing rate, indicating the rate at which the signal changes sign.
-    spectralCentroid: number // The center of mass of the spectrum, indicating the brightness of the sound.
-    spectralFlatness: number // Measure of the flatness of the spectrum, indicating how noise-like the signal is.
-    spectralRolloff: number // The frequency below which a specified percentage (usually 85%) of the total spectral energy lies.
-    spectralBandwidth: number // The width of the spectrum, indicating the range of frequencies present.
-    chromagram: number[] // Chromagram, representing the 12 different pitch classes of the audio.
-    tempo: number // Estimated tempo of the audio signal, measured in beats per minute (BPM).
-    hnr: number // Harmonics-to-noise ratio, indicating the proportion of harmonics to noise in the audio signal.
-}
-
-/**
- * Options to specify which audio features to extract.
- */
-export interface AudioFeaturesOptions {
-    energy?: boolean
-    mfcc?: boolean
-    rms?: boolean
-    zcr?: boolean
-    spectralCentroid?: boolean
-    spectralFlatness?: boolean
-    spectralRolloff?: boolean
-    spectralBandwidth?: boolean
-    chromagram?: boolean
-    tempo?: boolean
-    hnr?: boolean
-}
-
-/**
- * Represents a single data point in the audio analysis.
- */
-export interface DataPoint {
-    id: number
-    amplitude: number
-    activeSpeech?: boolean
-    dB?: number
-    silent?: boolean
-    features?: AudioFeatures
-    startTime?: number
-    endTime?: number
-    // start / end position in bytes
-    startPosition?: number
-    endPosition?: number
-    // number of audio samples for this point (samples size depends on bit depth)
-    samples?: number
-    // TODO: speaker detection
-    speaker?: number
-}
-
-export type AmplitudeAlgorithm = 'peak' | 'rms'
-
-/**
- * Represents the complete data from the audio analysis.
- */
-export interface AudioAnalysis {
-    pointsPerSecond: number // How many consolidated value per second
-    durationMs: number // Duration of the audio in milliseconds
-    bitDepth: number // Bit depth of the audio
-    samples: number // Size of the audio in bytes
-    numberOfChannels: number // Number of audio channels
-    sampleRate: number // Sample rate of the audio
-    dataPoints: DataPoint[] // Array of data points from the analysis.
-    amplitudeAlgorithm: AmplitudeAlgorithm // Algorithm used to calculate amplitude values.
-    amplitudeRange: {
-        min: number
-        max: number
-    }
-    // TODO: speaker detection
-    speakerChanges?: {
-        timestamp: number // Timestamp of the speaker change in milliseconds.
-        speaker: number // Speaker identifier.
-    }[]
-}
-

package/src/AudioAnalysis/extractAudioAnalysis.ts

@@ -1,147 +0,0 @@
-// packages/expo-audio-stream/src/AudioAnalysis/extractAudioAnalysis.ts
-import {
-    AmplitudeAlgorithm,
-    AudioAnalysis,
-    AudioFeaturesOptions,
-} from './AudioAnalysis.types'
-import ExpoAudioStreamModule from '../ExpoAudioStreamModule'
-import { isWeb } from '../constants'
-import { getLogger } from '../logger'
-import { convertPCMToFloat32 } from '../utils/convertPCMToFloat32'
-import { getWavFileInfo, WavFileInfo } from '../utils/getWavFileInfo'
-import { InlineFeaturesExtractor } from '../workers/InlineFeaturesExtractor.web'
-
-const logger = getLogger('extractAudioAnalysis')
-
-export interface ExtractAudioAnalysisProps {
-    fileUri?: string // should provide either fileUri or arrayBuffer
-    wavMetadata?: WavFileInfo
-    arrayBuffer?: ArrayBuffer
-    bitDepth?: number
-    skipWavHeader?: boolean
-    durationMs?: number
-    sampleRate?: number
-    numberOfChannels?: number
-    algorithm?: AmplitudeAlgorithm
-    position?: number // Optional number of bytes to skip. Default is 0
-    length?: number // Optional number of bytes to read.
-    pointsPerSecond?: number // Optional number of points per second. Use to reduce the number of points and compute the number of datapoints to return.
-    features?: AudioFeaturesOptions
-    featuresExtratorUrl?: string
-}
-
-export const extractAudioAnalysis = async ({
-    fileUri,
-    pointsPerSecond = 20,
-    arrayBuffer,
-    bitDepth,
-    skipWavHeader = true,
-    durationMs,
-    sampleRate,
-    numberOfChannels,
-    algorithm = 'rms',
-    features,
-    featuresExtratorUrl,
-}: ExtractAudioAnalysisProps): Promise<AudioAnalysis> => {
-    if (isWeb) {
-        if (!arrayBuffer && !fileUri) {
-            throw new Error('Either arrayBuffer or fileUri must be provided')
-        }
-
-        if (!arrayBuffer) {
-            logger.log(`fetching fileUri`, fileUri)
-            const response = await fetch(fileUri!)
-
-            if (!response.ok) {
-                throw new Error(
-                    `Failed to fetch fileUri: ${response.statusText}`
-                )
-            }
-
-            arrayBuffer = await response.arrayBuffer()
-            logger.log(`fetched fileUri`, arrayBuffer.byteLength, arrayBuffer)
-        }
-
-        // Create a new copy of the ArrayBuffer to avoid detachment issues
-        const bufferCopy = arrayBuffer.slice(0)
-        logger.log(
-            `extractAudioAnalysis skipWavHeader=${skipWavHeader} bitDepth=${bitDepth} len=${bufferCopy.byteLength}`,
-            bufferCopy.slice(0, 100)
-        )
-
-        let actualBitDepth = bitDepth
-        if (!actualBitDepth) {
-            logger.log(
-                `extractAudioAnalysis bitDepth not provided -- getting wav file info`
-            )
-            const fileInfo = await getWavFileInfo(bufferCopy)
-            actualBitDepth = fileInfo.bitDepth
-        }
-        logger.log(`extractAudioAnalysis actualBitDepth=${actualBitDepth}`)
-
-        const {
-            pcmValues: channelData,
-            min,
-            max,
-        } = await convertPCMToFloat32({
-            buffer: arrayBuffer,
-            bitDepth: actualBitDepth,
-            skipWavHeader,
-        })
-        logger.log(
-            `extractAudioAnalysis skipWaveHeader=${skipWavHeader} convertPCMToFloat32 length=${channelData.length} range: [ ${min} :: ${max} ]`
-        )
-
-        return new Promise((resolve, reject) => {
-            let worker: Worker
-            if (featuresExtratorUrl) {
-                worker = new Worker(
-                    new URL(featuresExtratorUrl, window.location.href)
-                )
-            } else {
-                const blob = new Blob([InlineFeaturesExtractor], {
-                    type: 'application/javascript',
-                })
-                const url = URL.createObjectURL(blob)
-                worker = new Worker(url)
-            }
-
-            worker.onmessage = (event) => {
-                resolve(event.data.result)
-            }
-
-            worker.onerror = (error) => {
-                reject(error)
-            }
-
-            worker.postMessage({
-                command: 'process',
-                channelData,
-                sampleRate,
-                pointsPerSecond,
-                algorithm,
-                bitDepth,
-                fullAudioDurationMs: durationMs,
-                numberOfChannels,
-            })
-        })
-    } else {
-        if (!fileUri) {
-            throw new Error('fileUri is required')
-        }
-        logger.log(`extractAudioAnalysis`, {
-            fileUri,
-            pointsPerSecond,
-            algorithm,
-        })
-        const res = await ExpoAudioStreamModule.extractAudioAnalysis({
-            fileUri,
-            pointsPerSecond,
-            skipWavHeader,
-            algorithm,
-            features,
-        })
-        logger.log(`extractAudioAnalysis`, res)
-        return res
-    }
-}

package/src/AudioAnalysis/extractWaveform.ts

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