@siteed/expo-audio-stream 1.5.1 → 1.6.1

package/build/workers/InlineFeaturesExtractor.web.js

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

@@ -0,0 +1,251 @@
+export const InlineAudioWebWorker = `
+const DEFAULT_BIT_DEPTH = 32
+const DEFAULT_SAMPLE_RATE = 44100
+
+class RecorderProcessor extends AudioWorkletProcessor {
+    constructor() {
+        super()
+        this.recordedBuffers = [] // Float32Array
+        this.newRecBuffer = [] // Float32Array
+        this.resampledBuffer = [] // Float32Array
+        this.exportIntervalSamples = 0
+        this.samplesSinceLastExport = 0
+        this.recordSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten
+        this.exportSampleRate = DEFAULT_SAMPLE_RATE // To be overwritten
+        this.recordBitDepth = DEFAULT_BIT_DEPTH // Default to 32-bit depth
+        this.exportBitDepth = DEFAULT_BIT_DEPTH // To be overwritten
+        this.numberOfChannels = 1 // Default to 1 channel (mono)
+        this.isRecording = true
+        this.port.onmessage = this.handleMessage.bind(this)
+    }
+
+    handleMessage(event) {
+        switch (event.data.command) {
+            case 'init':
+                this.recordSampleRate = event.data.recordSampleRate
+                this.exportSampleRate =
+                    event.data.exportSampleRate || event.data.recordSampleRate
+                this.exportIntervalSamples =
+                    this.recordSampleRate * (event.data.interval / 1000)
+                if (event.data.numberOfChannels) {
+                    this.numberOfChannels = event.data.numberOfChannels
+                }
+                if (event.data.recordBitDepth) {
+                    this.recordBitDepth = event.data.recordBitDepth
+                }
+                this.exportBitDepth =
+                    event.data.exportBitDepth ||
+                    this.recordBitDepth ||
+                    DEFAULT_BIT_DEPTH
+                break
+            case 'stop':
+                this.isRecording = false
+                this.getAllRecordedData()
+                    .then((fullRecordedData) => {
+                        this.port.postMessage({
+                            command: 'recordedData',
+                            recordedData: fullRecordedData,
+                            bitDepth: this.exportBitDepth,
+                            sampleRate: this.exportSampleRate,
+                        })
+                        return fullRecordedData
+                    })
+                    .catch((error) => {
+                        console.error(
+                            'RecorderProcessor Error extracting recorded data:',
+                            error
+                        )
+                    })
+                break
+        }
+    }
+
+    process(inputs, _outputs, _parameters) {
+        if (!this.isRecording) return true
+        const input = inputs[0]
+        if (input.length > 0) {
+            const newBuffer = new Float32Array(input[0])
+            this.newRecBuffer.push(newBuffer)
+            this.recordedBuffers.push(newBuffer)
+            this.samplesSinceLastExport += newBuffer.length
+
+            if (this.samplesSinceLastExport >= this.exportIntervalSamples) {
+                this.exportNewData()
+                this.samplesSinceLastExport = 0
+            }
+        }
+        return true
+    }
+
+    mergeBuffers(bufferArray, recLength) {
+        const result = new Float32Array(recLength)
+        let offset = 0
+        for (let i = 0; i < bufferArray.length; i++) {
+            result.set(bufferArray[i], offset)
+            offset += bufferArray[i].length
+        }
+        return result
+    }
+
+    floatTo16BitPCM(input) {
+        const output = new Int16Array(input.length)
+        for (let i = 0; i < input.length; i++) {
+            const s = Math.max(-1, Math.min(1, input[i]))
+            output[i] = s < 0 ? s * 0x8000 : s * 0x7fff
+        }
+        console.debug(
+            'RecorderProcessor Float to 16-bit PCM conversion complete. Output byte length:',
+            output.byteLength
+        )
+        return output
+    }
+
+    floatTo32BitPCM(input) {
+        const output = new Int32Array(input.length)
+        for (let i = 0; i < input.length; i++) {
+            const s = Math.max(-1, Math.min(1, input[i]))
+            output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff
+        }
+        console.debug(
+            'RecorderProcessor Float to 32-bit PCM conversion complete. Output byte length:',
+            output.byteLength
+        )
+        return output
+    }
+
+    resample(samples, targetSampleRate) {
+        if (this.recordSampleRate === targetSampleRate) {
+            return samples
+        }
+        const resampledBuffer = new Float32Array(
+            (samples.length * targetSampleRate) / this.recordSampleRate
+        )
+        const ratio = this.recordSampleRate / targetSampleRate
+        let offset = 0
+        for (let i = 0; i < resampledBuffer.length; i++) {
+            const nextOffset = Math.floor((i + 1) * ratio)
+            let accum = 0
+            let count = 0
+            for (let j = offset; j < nextOffset && j < samples.length; j++) {
+                accum += samples[j]
+                count++
+            }
+            resampledBuffer[i] = accum / count
+            offset = nextOffset
+        }
+        return resampledBuffer
+    }
+
+    async resampleBuffer(buffer, targetSampleRate) {
+        if (typeof OfflineAudioContext === 'undefined') {
+            return this.resample(buffer, targetSampleRate)
+        }
+
+        if (this.recordSampleRate === targetSampleRate) {
+            return buffer
+        }
+        const offlineContext = new OfflineAudioContext(
+            this.numberOfChannels,
+            buffer.length,
+            this.recordSampleRate
+        )
+        const sourceBuffer = offlineContext.createBuffer(
+            this.numberOfChannels,
+            buffer.length,
+            this.recordSampleRate
+        )
+        sourceBuffer.copyToChannel(buffer, 0)
+
+        const bufferSource = offlineContext.createBufferSource()
+        bufferSource.buffer = sourceBuffer
+        bufferSource.connect(offlineContext.destination)
+        bufferSource.start()
+
+        const renderedBuffer = await offlineContext.startRendering()
+
+        const resampledBuffer = new Float32Array(renderedBuffer.length)
+        renderedBuffer.copyFromChannel(resampledBuffer, 0)
+
+        return resampledBuffer
+    }
+
+    async exportNewData() {
+        // Calculate the total length of the new recorded buffers
+        const length = this.newRecBuffer.reduce(
+            (acc, buffer) => acc + buffer.length,
+            0
+        )
+
+        // Merge all new recorded buffers into a single buffer
+        const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length)
+
+        const resampledBuffer = await this.resampleBuffer(
+            mergedBuffer,
+            this.exportSampleRate
+        )
+
+        let finalBuffer = resampledBuffer // Float32Array
+        if (this.recordBitDepth !== this.exportBitDepth) {
+            if (this.exportBitDepth === 16) {
+                finalBuffer = this.floatTo16BitPCM(resampledBuffer)
+            } else if (this.exportBitDepth === 32) {
+                finalBuffer = this.floatTo32BitPCM(resampledBuffer)
+            }
+        }
+
+        const originalSize = mergedBuffer.byteLength
+        const resampledSize = resampledBuffer.byteLength
+        const finalSize = finalBuffer.byteLength
+
+        // Clear the new recorded buffers after they have been processed
+        this.newRecBuffer.length = 0
+
+        // Post the message to the main thread
+        // The first argument is the message data, containing the encoded WAV buffer
+        // The second argument is the transfer list, which transfers ownership of the ArrayBuffer
+        // to the main thread, avoiding the need to copy the buffer and improving performance
+        // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);
+        this.port.postMessage(
+            {
+                command: 'newData',
+                recordedData: finalBuffer,
+                sampleRate: this.exportSampleRate,
+                bitDepth: this.exportBitDepth,
+            },
+            []
+        )
+    }
+
+    async getAllRecordedData() {
+        const length = this.recordedBuffers.reduce(
+            (acc, buffer) => acc + buffer.length,
+            0
+        )
+        const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length)
+        const resampledBuffer = await this.resampleBuffer(
+            mergedBuffer,
+            this.exportSampleRate
+        )
+        // Convert to the desired bit depth if necessary
+        let finalBuffer = resampledBuffer
+        if (this.recordBitDepth !== this.exportBitDepth) {
+            if (this.exportBitDepth === 16) {
+                finalBuffer = this.floatTo16BitPCM(resampledBuffer)
+            } else if (this.exportBitDepth === 32) {
+                finalBuffer = this.floatTo32BitPCM(resampledBuffer)
+            }
+        }
+
+        const originalSize = mergedBuffer.byteLength
+        const resampledSize = resampledBuffer.byteLength
+        const finalSize = finalBuffer.byteLength
+
+        this.recordedBuffers.length = 0 // Clear the buffers after extraction
+
+        return finalBuffer
+    }
+}
+
+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/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+    "platforms": ["ios", "android", "web"],
+    "ios": {
+        "modules": ["ExpoAudioStreamModule"]
+    },
+    "android": {
+        "modules": ["net.siteed.audiostream.ExpoAudioStreamModule"]
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",
@@ -26,10 +26,16 @@
     "android",
     "ios",
     "cpp",
+    "plugin",
+    "app.plugin.js",
+    "LICENSE",
+    "CHANGELOG.md",
     "generated",
+    "expo-module.config.json",
     "README.md",
     "package.json",
     "*.podspec",
+    "build",
     "!ios/build",
     "!android/build",
     "!android/gradle",