npm - hypnosound - Versions diffs - 1.7.2 → 1.8.1 - Mend

hypnosound 1.7.2 → 1.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/.eslintrc +4 -3
package/index.html +70 -19
package/index.js +15 -29
package/package.json +1 -1
package/src/audio/bass.js +5 -3
package/src/audio/energy.js +10 -4
package/src/audio/pitchClass.js +6 -6
package/src/audio/spectralKurtosis.js +7 -3
package/src/audio/spectralSkew.js +8 -1
package/src/utils/calculateStats.js +157 -151
package/window-processor.js +31 -0

package/.eslintrc CHANGED Viewed

@@ -1,10 +1,11 @@
 {
     "parserOptions": {
-        "ecmaVersion": 2023,
+        "ecmaVersion": 2024,
         "sourceType": "module"
     },
-    "plugins": ["prettier"],
+    "plugins": [
+        "prettier"
+    ],
     "rules": {
         "prettier/prettier": "warn"
     }

package/index.html CHANGED Viewed

@@ -4,6 +4,7 @@
         <meta charset="UTF-8" />
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
         <title>Audio Capture and Analysis</title>
+        <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
     </head>
     <body>
@@ -17,42 +18,92 @@
                     const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
                     const audioContext = new (window.AudioContext || window.webkitAudioContext)()
                     const source = audioContext.createMediaStreamSource(stream)
                     const analyser = audioContext.createAnalyser()
+                    analyser.fftSize = 32768
+                    analyser.smoothingTimeConstant = 0.5
+                    await audioContext.audioWorklet.addModule('window-processor.js') // Path to your processor file
+                    const windowNode = new AudioWorkletNode(audioContext, 'window-processor')
-                    source.connect(analyser)
-                    analyser.fftSize = 32768 / 2 // Or whatever size you need
-                    analyser.smoothingTimeConstant = 0
+                    source.connect(windowNode)
+                    windowNode.connect(analyser)
                     const bufferLength = analyser.frequencyBinCount
                     const dataArray = new Uint8Array(bufferLength)
-                    const draw = () => {
-                        requestAnimationFrame(draw)
+                    const update = () => {
+                        requestAnimationFrame(update)
                         analyser.getByteFrequencyData(dataArray)
                         // This is where the magic happens, but be careful what you log...
-                        console.log({
-                            //   energy: a.energy(dataArray),
-                            //   spectralCentroid: a.spectralCentroid(dataArray),
-                            //   spectralCrest: a.spectralCrest(dataArray),
-                            //   spectralEntropy: a.spectralEntropy(dataArray),
-                            //   spectralFlux: a.spectralFlux(dataArray),
-                            //   spectralKurtosis: a.spectralKurtosis(dataArray),
-                            //   spectralRolloff: a.spectralRolloff(dataArray),
-                            //   spectralRoughness: a.spectralRoughness(dataArray),
-                            //   spectralSkew: a.spectralSkew(dataArray),
-                            //   spectralSpread: a.spectralSpread(dataArray),
+                        window.audioSignals = {
+                            energy: a.energy(dataArray),
+                            spectralCentroid: a.spectralCentroid(dataArray),
+                            spectralCrest: a.spectralCrest(dataArray),
+                            spectralEntropy: a.spectralEntropy(dataArray),
+                            spectralFlux: a.spectralFlux(dataArray),
+                            spectralKurtosis: a.spectralKurtosis(dataArray),
+                            spectralRolloff: a.spectralRolloff(dataArray),
+                            spectralRoughness: a.spectralRoughness(dataArray),
+                            spectralSkew: a.spectralSkew(dataArray),
+                            spectralSpread: a.spectralSpread(dataArray),
                             bass: a.bass(dataArray),
                             mids: a.mids(dataArray),
                             treble: a.treble(dataArray),
-                        })
+                            pitchClass: a.pitchClass(dataArray),
+                        }
+                        window.fft = dataArray
                     }
-                    draw()
+                    update()
                 } catch (error) {
                     console.error('Something went wrong:', error)
                 }
             })
         </script>
+        <canvas id="myBarChart" width="800" height="400"></canvas>
+        <canvas id="fftBarChart" width="800" height="400"></canvas>
+        <script>
+            var ctx = document.getElementById('myBarChart').getContext('2d')
+            var myBarChart = new Chart(ctx, {
+                type: 'bar',
+                data: {
+                    labels: [], // Initial empty labels
+                    datasets: [
+                        {
+                            label: 'Audio Data',
+                            data: [], // Initial empty data
+                            backgroundColor: 'rgba(54, 162, 235, 0.2)',
+                            borderColor: 'rgba(54, 162, 235, 1)',
+                            borderWidth: 1,
+                        },
+                    ],
+                },
+                options: {
+                    scales: {
+                        y: {
+                            beginAtZero: true,
+                        },
+                    },
+                    responsive: true,
+                    animation: {
+                        duration: 0, // Turn off animation for instant updates
+                    },
+                },
+            })
+            // Function to update the chart with a new data object
+            function updateChartData(newData) {
+                myBarChart.data.labels = Object.keys(newData)
+                myBarChart.data.datasets[0].data = Object.values(newData).map(({ value }) => value || 0)
+                myBarChart.update()
+            }
+            function render() {
+                requestAnimationFrame(render)
+                updateChartData(window.audioSignals || {})
+            }
+            render()
+        </script>
     </body>
 </html>

package/index.js CHANGED Viewed

@@ -51,96 +51,82 @@ class AudioProcessor {
     }
     energy = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = energy(windowedFft)
+        const value = energy(fft)
         const stats = this.statCalculators.energy(value)
         return { value, stats }
     }
     spectralCentroid = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralCentroid(applyKaiserWindow(windowedFft))
+        const value = spectralCentroid(applyKaiserWindow(fft))
         const stats = this.statCalculators.spectralCentroid(value)
         return { value, stats }
     }
     spectralCrest = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralCrest(windowedFft)
+        const value = spectralCrest(fft)
         const stats = this.statCalculators.spectralCentroid(value)
         return { value, stats }
     }
     spectralEntropy = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralEntropy(windowedFft)
+        const value = spectralEntropy(fft)
         const stats = this.statCalculators.spectralEntropy(value)
         return { value, stats }
     }
     spectralFlux = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralFlux(windowedFft, this.previousValue.spectralFlux)
-        this.previousValue.spectralFlux = new Uint8Array(windowedFft)
+        const value = spectralFlux(fft, this.previousValue.spectralFlux)
+        this.previousValue.spectralFlux = new Uint8Array(fft)
         const stats = this.statCalculators.spectralFlux(value)
         return { value, stats }
     }
     spectralKurtosis = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralKurtosis(windowedFft)
+        const value = spectralKurtosis(fft)
         const stats = this.statCalculators.spectralKurtosis(value)
         return { value, stats }
     }
     spectralRolloff = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralRolloff(windowedFft)
+        const value = spectralRolloff(fft)
         const stats = this.statCalculators.spectralRolloff(value)
         return { value, stats }
     }
     spectralRoughness = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralRoughness(windowedFft)
+        const value = spectralRoughness(fft)
         const stats = this.statCalculators.spectralRoughness(value)
         return { value, stats }
     }
     spectralSkew = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralSkew(windowedFft)
+        const value = spectralSkew(fft)
         const stats = this.statCalculators.spectralSkew(value)
         return { value, stats }
     }
     spectralSpread = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = spectralSpread(windowedFft)
+        const value = spectralSpread(fft)
         const stats = this.statCalculators.spectralSpread(value)
         return { value, stats }
     }
     pitchClass = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = pitchClass(windowedFft)
+        const value = pitchClass(fft)
         const stats = this.statCalculators.pitchClass(value)
         return { value, stats }
     }
     bass = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = bass(windowedFft)
+        const value = bass(fft)
         const stats = this.statCalculators.bass(value)
         return { value, stats }
     }
     treble = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = treble(windowedFft)
+        const value = treble(fft)
         const stats = this.statCalculators.treble(value)
         return { value, stats }
     }
     mids = (fft) => {
-        const windowedFft = applyKaiserWindow(fft)
-        const value = mids(windowedFft)
+        const value = mids(fft)
         const stats = this.statCalculators.mids(value)
         return { value, stats }
     }

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
     "name": "hypnosound",
     "type": "module",
-    "version": "1.7.2",
+    "version": "1.8.1",
     "description": "A small library for analyzing audio",
     "main": "index.js",
     "scripts": {

package/src/audio/bass.js CHANGED Viewed

@@ -15,7 +15,8 @@ function calculateBassPower(fft, sampleRate, totalSamples) {
     for (let i = 0; i < fft.length; i++) {
         let frequency = i * frequencyResolution
-        let magnitude = Math.abs(fft[i]) / totalSamples
+        // Normalize each FFT value from 0 to 1 (assuming Uint8Array values 0-255)
+        let magnitude = fft[i] / 255
         let power = magnitude * magnitude
         // Accumulate max energy for normalization
@@ -26,7 +27,8 @@ function calculateBassPower(fft, sampleRate, totalSamples) {
             bassEnergy += power
         }
     }
     // Normalize bass energy from 0 to 1
-    let normalizedBassPower = bassEnergy / maxEnergy
-    return isNaN(normalizedBassPower) ? 0 : normalizedBassPower // Scale by 10 if needed, similar to your original function
+    let normalizedBassPower = maxEnergy > 0 ? bassEnergy / maxEnergy : 0
+    return isNaN(normalizedBassPower) ? 0 : normalizedBassPower
 }

package/src/audio/energy.js CHANGED Viewed

@@ -1,13 +1,19 @@
 export default function energy(fft) {
-    return calculateFFTEnergy(fft)
+    return calculateFFTEnergy(fft) / 1000
 }
 function calculateFFTEnergy(currentSignal) {
     let energy = 0
+    const maxPossibleValue = 1 // This should be 1 if your data is normalized between 0 and 1
+    const maxPossibleEnergy = currentSignal.length // Total samples if each sample was at maximum value
     for (let i = 0; i < currentSignal.length; i++) {
-        let normalizedValue = currentSignal[i] / currentSignal.length
-        energy += normalizedValue * normalizedValue
+        let normalizedValue = currentSignal[i] / maxPossibleValue // Normalize each FFT value
+        energy += normalizedValue * normalizedValue // Sum the squares of the normalized values
     }
-    return energy * 2
+    // Normalize the computed energy by the number of samples since each sample's max energy would be 1 if maxPossibleValue is 1
+    energy = energy / currentSignal.length
+    return energy
 }

package/src/audio/pitchClass.js CHANGED Viewed

@@ -1,13 +1,13 @@
-export default function pitchClass(fft) {
+export default function pitchClass(fft, sampleRate = 44100) {
     // Constants for the FFT processing
-    const sampleRate = 44100 // This could vary
-    const fftSize = fft.length // This is an example, adjust based on your FFT setup
+    const fftSize = fft.length
     const freqResolution = sampleRate / fftSize
     // Finding the dominant frequency in the FFT data
     let maxIndex = 0
     let maxValue = 0
-    for (let i = 0; i < fft.length; i++) {
+    for (let i = 1; i < fft.length; i++) {
+        // start from 1 to skip DC offset
         if (fft[i] > maxValue) {
             maxValue = fft[i]
             maxIndex = i
@@ -15,9 +15,9 @@ export default function pitchClass(fft) {
     }
     const dominantFreq = maxIndex * freqResolution
-    // Convert to MIDI note then to pitchClass class
+    // Convert to MIDI note then to pitchClass
     const midiNote = 69 + 12 * Math.log2(dominantFreq / 440)
-    const pitchClass = midiNote % 12
+    const pitchClass = Math.round(midiNote) % 12 // round to reduce minor fluctuation effects
     // Normalize to a 0-1 range
     const normalizedpitchClass = pitchClass / 12

package/src/audio/spectralKurtosis.js CHANGED Viewed

@@ -1,7 +1,11 @@
 import mu from '../utils/mu.js'
 export default function spectralKurtosis(fft) {
-    const value = calculateSpectralKurtosis(fft) // Process FFT data
-    return value / 1000
+    const computed = calculateSpectralKurtosis(fft) // Process FFT data
+    // Normalize using a logistic function
+    const k = 0.05 // Adjust k based on the expected range of kurtosis values
+    const value = 1 / (1 + Math.exp(-k * computed))
+    return value
 }
 function calculateSpectralKurtosis(fftData) {
@@ -15,7 +19,7 @@ function calculateSpectralKurtosis(fftData) {
     }
     fourthMoment /= fftData.length
-    // Add a small epsilon to the denominator to prevent gigantic scores when variance is very small
+    // Add a small epsilon to the denominator to prevent division by a very small number
     const epsilon = 1e-7 // Adjust epsilon based on the scale of your data
     const kurtosis = variance ? fourthMoment / Math.pow(variance + epsilon, 2) - 3 : 0
     return kurtosis

package/src/audio/spectralSkew.js CHANGED Viewed

@@ -1,10 +1,17 @@
 export default function spectralSkew(fft) {
     const computed = calculateSpectralSkewness(fft) || 0 // Process FFT data
-    const value = computed / 10
+    // Adjust the steepness factor (k) based on expected skewness range
+    const k = 0.05 // Decrease this value if skewness values are large
+    // Apply a logistic function to map the result to (0, 1)
+    const value = 1 / (1 + Math.exp(-k * computed))
     return value
 }
 function calculateSpectralSkewness(fftData) {
+    if (fftData.length === 0) {
+        return 0 // Guard against division by zero if fftData is empty
+    }
     const mean = fftData.reduce((sum, val) => sum + val, 0) / fftData.length
     const variance = fftData.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / fftData.length
     const standardDeviation = Math.sqrt(variance)

package/src/utils/calculateStats.js CHANGED Viewed

@@ -1,200 +1,206 @@
 export const StatTypes = ['normalized', 'mean', 'median', 'standardDeviation', 'zScore', 'min', 'max']
-export function makeCalculateStats(historySize = 500) {
-    let queue = []
-    let sum = 0
-    let sumOfSquares = 0
-    let minQueue = []
-    let maxQueue = []
-    let lowerHalf = [] // Max heap
-    let upperHalf = [] // Min heap
-    function updateMinMaxQueues(value) {
-        while (minQueue.length && minQueue[minQueue.length - 1] > value) {
-            minQueue.pop()
-        }
-        while (maxQueue.length && maxQueue[maxQueue.length - 1] < value) {
-            maxQueue.pop()
-        }
-        minQueue.push(value)
-        maxQueue.push(value)
-    }
+const erf = (x) => {
+    const a1 = 0.254829592
+    const a2 = -0.284496736
+    const a3 = 1.421413741
+    const a4 = -1.453152027
+    const a5 = 1.061405429
+    const p = 0.3275911
-    function removeOldFromMinMaxQueues(oldValue) {
-        if (minQueue[0] === oldValue) {
-            minQueue.shift()
-        }
-        if (maxQueue[0] === oldValue) {
-            maxQueue.shift()
-        }
-    }
+    const sign = x < 0 ? -1 : 1
+    x = Math.abs(x)
-    function addNumberToHeaps(number) {
-        if (lowerHalf.length === 0 || number < lowerHalf[0]) {
-            lowerHalf.push(number)
-            bubbleUp(lowerHalf, false)
-        } else {
-            upperHalf.push(number)
-            bubbleUp(upperHalf, true)
-        }
+    const t = 1.0 / (1.0 + p * x)
+    const y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x)
-        // Rebalance heaps
-        if (lowerHalf.length > upperHalf.length + 1) {
-            upperHalf.push(extractTop(lowerHalf, false))
-            bubbleUp(upperHalf, true)
-        } else if (upperHalf.length > lowerHalf.length) {
-            lowerHalf.push(extractTop(upperHalf, true))
-            bubbleUp(lowerHalf, false)
-        }
-    }
+    return sign * y
+}
-    function removeNumberFromHeaps(number) {
-        if (lowerHalf.includes(number)) {
-            removeNumber(lowerHalf, number, false)
-        } else if (upperHalf.includes(number)) {
-            removeNumber(upperHalf, number, true)
-        }
+class MonotonicQueue {
+    constructor(isMin = true) {
+        this.deque = []
+        this.compare = isMin ? (a, b) => a > b : (a, b) => a < b
+    }
-        // Rebalance heaps
-        if (lowerHalf.length > upperHalf.length + 1) {
-            upperHalf.push(extractTop(lowerHalf, false))
-            bubbleUp(upperHalf, true)
-        } else if (upperHalf.length > lowerHalf.length) {
-            lowerHalf.push(extractTop(upperHalf, true))
-            bubbleUp(lowerHalf, false)
+    push(value) {
+        while (this.deque.length && this.compare(this.deque[this.deque.length - 1], value)) {
+            this.deque.pop()
         }
+        this.deque.push(value)
     }
-    function bubbleUp(heap, isMinHeap) {
-        let index = heap.length - 1
-        while (index > 0) {
-            let parentIdx = Math.floor((index - 1) / 2)
-            if ((isMinHeap && heap[index] < heap[parentIdx]) || (!isMinHeap && heap[index] > heap[parentIdx])) {
-                ;[heap[index], heap[parentIdx]] = [heap[parentIdx], heap[index]]
-                index = parentIdx
-            } else {
-                break
-            }
-        }
+    remove(value) {
+        if (!this.deque.length || this.deque[0] !== value) return
+        this.deque.shift()
     }
-    function extractTop(heap, isMinHeap) {
-        if (heap.length === 0) {
-            return null
-        }
-        let top = heap[0]
-        heap[0] = heap[heap.length - 1]
-        heap.pop()
-        sinkDown(heap, isMinHeap)
-        return top
+    peek = () => this.deque[0]
+}
+const bubbleUp = (heap, isMinHeap) => {
+    let index = heap.length - 1
+    const value = heap[index]
+    while (index > 0) {
+        const parentIdx = Math.floor((index - 1) / 2)
+        const shouldSwap = isMinHeap ? heap[index] < heap[parentIdx] : heap[index] > heap[parentIdx]
+        if (!shouldSwap) break
+        heap[index] = heap[parentIdx]
+        index = parentIdx
     }
-    function sinkDown(heap, isMinHeap) {
-        let index = 0
-        let length = heap.length
+    heap[index] = value
+}
-        while (index < length) {
-            let leftChildIndex = 2 * index + 1
-            let rightChildIndex = 2 * index + 2
-            let swapIndex = null
+const getBestChildIndex = (heap, leftChildIndex, rightChildIndex, isMinHeap) => {
+    if (rightChildIndex >= heap.length) return leftChildIndex
-            if (leftChildIndex < length) {
-                if ((isMinHeap && heap[leftChildIndex] < heap[index]) || (!isMinHeap && heap[leftChildIndex] > heap[index])) {
-                    swapIndex = leftChildIndex
-                }
-            }
+    const comparator = isMinHeap ? Math.min : Math.max
+    return comparator(heap[leftChildIndex], heap[rightChildIndex]) === heap[leftChildIndex] ? leftChildIndex : rightChildIndex
+}
-            if (rightChildIndex < length) {
-                if (
-                    (isMinHeap && heap[rightChildIndex] < (swapIndex === null ? heap[index] : heap[leftChildIndex])) ||
-                    (!isMinHeap && heap[rightChildIndex] > (swapIndex === null ? heap[index] : heap[leftChildIndex]))
-                ) {
-                    swapIndex = rightChildIndex
-                }
-            }
+const sinkDown = (heap, isMinHeap) => {
+    let index = 0
+    const value = heap[0]
+    const length = heap.length
-            if (swapIndex === null) {
-                break
-            }
+    while (true) {
+        const leftChildIndex = 2 * index + 1
+        if (leftChildIndex >= length) break
-            ;[heap[index], heap[swapIndex]] = [heap[swapIndex], heap[index]]
-            index = swapIndex
-        }
+        const bestChildIndex = getBestChildIndex(heap, leftChildIndex, 2 * index + 2, isMinHeap)
+        const shouldSwap = isMinHeap ? heap[bestChildIndex] < value : heap[bestChildIndex] > value
+        if (!shouldSwap) break
+        heap[index] = heap[bestChildIndex]
+        index = bestChildIndex
+    }
+    heap[index] = value
+}
+export const makeCalculateStats = (historySize = 500) => {
+    const queue = []
+    const minQueue = new MonotonicQueue(true)
+    const maxQueue = new MonotonicQueue(false)
+    const lowerHalf = [] // Max heap
+    const upperHalf = [] // Min heap
+    let sum = 0
+    let sumOfSquares = 0
+    const getTargetHeap = (value) => {
+        if (lowerHalf.length === 0 || value < lowerHalf[0]) return { target: lowerHalf, isMin: false }
+        return { target: upperHalf, isMin: true }
+    }
+    const addToHeaps = (value) => {
+        const heap = getTargetHeap(value)
+        heap.target.push(value)
+        bubbleUp(heap.target, heap.isMin)
+        rebalanceHeaps()
     }
-    function removeNumber(heap, number, isMinHeap) {
-        let index = heap.indexOf(number)
-        if (index !== -1) {
-            heap[index] = heap[heap.length - 1]
-            heap.pop()
-            sinkDown(heap, isMinHeap)
+    const removeNumberFromHeaps = (number) => {
+        if (lowerHalf.includes(number)) {
+            const index = lowerHalf.indexOf(number)
+            lowerHalf[index] = lowerHalf[lowerHalf.length - 1]
+            lowerHalf.pop()
+            sinkDown(lowerHalf, false)
+        } else if (upperHalf.includes(number)) {
+            const index = upperHalf.indexOf(number)
+            upperHalf[index] = upperHalf[upperHalf.length - 1]
+            upperHalf.pop()
+            sinkDown(upperHalf, true)
         }
+        rebalanceHeaps()
     }
-    function calculateMedian() {
-        if (lowerHalf.length === upperHalf.length) {
-            return (lowerHalf[0] + upperHalf[0]) / 2
-        } else {
-            return lowerHalf[0]
+    const rebalanceHeaps = () => {
+        if (lowerHalf.length <= upperHalf.length + 1 && upperHalf.length <= lowerHalf.length) return
+        if (lowerHalf.length > upperHalf.length + 1) {
+            const value = extractTop(lowerHalf)
+            upperHalf.push(value)
+            bubbleUp(upperHalf, true)
+            return
         }
+        const value = extractTop(upperHalf)
+        lowerHalf.push(value)
+        bubbleUp(lowerHalf, false)
     }
-    function erf(x) {
-        // Constants
-        const a1 = 0.254829592
-        const a2 = -0.284496736
-        const a3 = 1.421413741
-        const a4 = -1.453152027
-        const a5 = 1.061405429
-        const p = 0.3275911
-        // Save the sign of x
-        const sign = x < 0 ? -1 : 1
-        x = Math.abs(x)
-        // A&S formula 7.1.26
-        const t = 1.0 / (1.0 + p * x)
-        const y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x)
-        return sign * y
+    const extractTop = (heap) => {
+        if (!heap.length) return null
+        const top = heap[0]
+        heap[0] = heap[heap.length - 1]
+        heap.pop()
+        sinkDown(heap, heap === upperHalf)
+        return top
     }
-    function normalizeZScore(zScore) {
-        return 0.5 * (1 + erf(zScore / Math.sqrt(2)))
+    const calculateMedian = () => {
+        if (!lowerHalf.length) return queue[0] || 0
+        if (lowerHalf.length === upperHalf.length) return (lowerHalf[0] + upperHalf[0]) / 2
+        return lowerHalf[0]
     }
-    return function calculateStats(value) {
-        if (typeof value !== 'number') throw new Error('Input must be a number')
-        updateMinMaxQueues(value)
-        addNumberToHeaps(value)
+    const calculate = (value) => {
+        if (typeof value !== 'number' || isNaN(value)) throw new Error('Input must be a valid number')
+        minQueue.push(value)
+        maxQueue.push(value)
+        addToHeaps(value)
         queue.push(value)
         sum += value
         sumOfSquares += value * value
         if (queue.length > historySize) {
-            let removed = queue.shift()
+            const removed = queue.shift()
             sum -= removed
             sumOfSquares -= removed * removed
-            removeOldFromMinMaxQueues(removed)
+            minQueue.remove(removed)
+            maxQueue.remove(removed)
             removeNumberFromHeaps(removed)
         }
-        let mean = sum / queue.length
-        let variance = sumOfSquares / queue.length - mean * mean
-        let min = minQueue.length ? minQueue[0] : 0
-        let max = maxQueue.length ? maxQueue[0] : 0
-        let median = calculateMedian()
-        let normalized = queue.length ? (value - min) / (max - min) : 0
-        let zScore = variance ? (value - mean) / Math.sqrt(variance) : 0
+        const mean = sum / queue.length
+        const variance = Math.max(0, sumOfSquares / queue.length - mean * mean)
+        const min = minQueue.peek() || 0
+        const max = maxQueue.peek() || 0
+        if (max === min) {
+            return {
+                current: value,
+                zScore: 1,
+                normalized: 0.5,
+                standardDeviation: 0,
+                median: value,
+                mean,
+                min,
+                max,
+            }
+        }
+        const stdDev = Math.sqrt(variance)
         return {
             current: value,
-            zScore: zScore / 2.5,
-            normalized,
-            standardDeviation: Math.sqrt(variance),
-            median,
+            zScore: stdDev > 0 ? (value - mean) / (stdDev * 2.5) : 0,
+            normalized: (value - min) / (max - min),
+            standardDeviation: stdDev,
+            median: calculateMedian(),
             mean,
             min,
             max,
         }
     }
+    calculate.queue = queue
+    return calculate
 }

package/window-processor.js ADDED Viewed

@@ -0,0 +1,31 @@
+class WindowProcessor extends AudioWorkletProcessor {
+    static get parameterDescriptors() {
+        return [] // Add any parameters you might need, like window type
+    }
+    constructor() {
+        super()
+    }
+    process(inputs, outputs, parameters) {
+        const input = inputs[0]
+        const output = outputs[0]
+        if (input.length > 0) {
+            const windowLength = input[0].length
+            for (let channel = 0; channel < input.length; channel++) {
+                const inputChannel = input[channel]
+                const outputChannel = output[channel]
+                for (let i = 0; i < windowLength; i++) {
+                    // Apply a Hanning window as an example
+                    const windowCoeff = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (windowLength - 1)))
+                    outputChannel[i] = inputChannel[i] * windowCoeff
+                }
+            }
+        }
+        return true // Keep processor alive
+    }
+}
+registerProcessor('window-processor', WindowProcessor)