hypnosound 1.8.0 → 1.9.0

package/.eslintrc

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

package/.nvmrc

@@ -1 +1 @@
-v21.6.1
+v21.6.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 hypnodroid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 hypnodroid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.js

@@ -1,153 +1,29 @@
 import { StatTypes, makeCalculateStats } from './src/utils/calculateStats.js'
-import { applyKaiserWindow } from './src/utils/applyKaiserWindow.js'
-import energy from './src/audio/energy.js'
-import spectralCentroid from './src/audio/spectralCentroid.js'
-import spectralCrest from './src/audio/spectralCrest.js'
-import spectralEntropy from './src/audio/spectralEntropy.js'
-import spectralFlux from './src/audio/spectralFlux.js'
-import spectralKurtosis from './src/audio/spectralKurtosis.js'
-import spectralRolloff from './src/audio/spectralRolloff.js'
-import spectralRoughness from './src/audio/spectralRoughness.js'
-import spectralSkew from './src/audio/spectralSkew.js'
-import spectralSpread from './src/audio/spectralSpread.js'
-import pitchClass from './src/audio/pitchClass.js'
-import bass from './src/audio/bass.js'
-import treble from './src/audio/treble.js'
-import mids from './src/audio/mids.js'
+export * from './src/audio/index.js'
+export { applyKaiserWindow } from './src/utils/applyKaiserWindow.js'
+export { StatTypes, makeCalculateStats } from './src/utils/calculateStats.js'
+import * as audio from './src/audio/index.js'
+
 class AudioProcessor {
     constructor() {
-        // aah, state management
-        this.statCalculators = {}
-        this.previousValue = {}
-
-        this.statCalculators.energy = makeCalculateStats()
-
-        this.statCalculators.spectralCentroid = makeCalculateStats()
-
-        this.statCalculators.spectralCrest = makeCalculateStats()
-
-        this.statCalculators.spectralEntropy = makeCalculateStats()
-
-        this.statCalculators.spectralFlux = makeCalculateStats()
-        this.previousValue.spectralFlux = null
-
-        this.statCalculators.spectralKurtosis = makeCalculateStats()
-
-        this.statCalculators.spectralRolloff = makeCalculateStats()
-
-        this.statCalculators.spectralSkew = makeCalculateStats()
-
-        this.statCalculators.spectralRoughness = makeCalculateStats()
-
-        this.statCalculators.spectralSpread = makeCalculateStats()
-
-        this.statCalculators.pitchClass = makeCalculateStats()
-
-        this.statCalculators.bass = makeCalculateStats()
-
-        this.statCalculators.treble = makeCalculateStats()
-
-        this.statCalculators.mids = makeCalculateStats()
-    }
-
-    energy = (fft) => {
-        const value = energy(fft)
-        const stats = this.statCalculators.energy(value)
-        return { value, stats }
-    }
-
-    spectralCentroid = (fft) => {
-        const value = spectralCentroid(applyKaiserWindow(fft))
-        const stats = this.statCalculators.spectralCentroid(value)
-        return { value, stats }
-    }
-
-    spectralCrest = (fft) => {
-        const value = spectralCrest(fft)
-        const stats = this.statCalculators.spectralCentroid(value)
-        return { value, stats }
-    }
-
-    spectralEntropy = (fft) => {
-        const value = spectralEntropy(fft)
-        const stats = this.statCalculators.spectralEntropy(value)
-        return { value, stats }
-    }
-
-    spectralFlux = (fft) => {
-        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 value = spectralKurtosis(fft)
-        const stats = this.statCalculators.spectralKurtosis(value)
-        return { value, stats }
-    }
-
-    spectralRolloff = (fft) => {
-        const value = spectralRolloff(fft)
-        const stats = this.statCalculators.spectralRolloff(value)
-        return { value, stats }
-    }
-
-    spectralRoughness = (fft) => {
-        const value = spectralRoughness(fft)
-        const stats = this.statCalculators.spectralRoughness(value)
-        return { value, stats }
-    }
-
-    spectralSkew = (fft) => {
-        const value = spectralSkew(fft)
-        const stats = this.statCalculators.spectralSkew(value)
-        return { value, stats }
-    }
-
-    spectralSpread = (fft) => {
-        const value = spectralSpread(fft)
-        const stats = this.statCalculators.spectralSpread(value)
-        return { value, stats }
-    }
-
-    pitchClass = (fft) => {
-        const value = pitchClass(fft)
-        const stats = this.statCalculators.pitchClass(value)
-        return { value, stats }
-    }
-    bass = (fft) => {
-        const value = bass(fft)
-        const stats = this.statCalculators.bass(value)
-        return { value, stats }
-    }
-    treble = (fft) => {
-        const value = treble(fft)
-        const stats = this.statCalculators.treble(value)
-        return { value, stats }
-    }
-    mids = (fft) => {
-        const value = mids(fft)
-        const stats = this.statCalculators.mids(value)
-        return { value, stats }
+        const { AudioFeatures } = audio
+        this.state = AudioFeatures.reduce((acc, feature) => {
+            acc[feature] = {
+                analyzer: audio[feature],
+                statCalculator: makeCalculateStats(),
+            }
+            return acc
+        }, {})
+        for (const feature of AudioFeatures) {
+            this[feature] = (fft) => {
+                const { previousValue = 0, statCalculator, analyzer } = this.state[feature]
+                const value = analyzer(fft, previousValue)
+                this.state[feature].previousValue = value
+                this.state[feature].statCalculator = statCalculator
+                this.state[feature].stats = statCalculator(value, previousValue)
+                return { value, ...this.state[feature] }
+            }
+        }
     }
 }
 export default AudioProcessor
-export {
-    energy,
-    spectralCentroid,
-    spectralCrest,
-    spectralEntropy,
-    spectralFlux,
-    spectralKurtosis,
-    spectralRolloff,
-    spectralRoughness,
-    spectralSkew,
-    spectralSpread,
-    pitchClass,
-    bass,
-    mids,
-    treble,
-    makeCalculateStats,
-    StatTypes,
-    applyKaiserWindow,
-}

package/package.json

@@ -1,13 +1,12 @@
 {
     "name": "hypnosound",
     "type": "module",
-    "version": "1.8.0",
+    "version": "1.9.0",
     "description": "A small library for analyzing audio",
     "main": "index.js",
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1",
-        "start": "live-server .",
-        "format": "eslint --fix ."
+        "start": "python -m http.server 1337",
+        "build": "bun scripts/generate-barrel.mjs"
     },
     "repository": {
         "type": "git",
@@ -23,10 +22,5 @@
     "bugs": {
         "url": "https://github.com/hypnodroid/hypnosound/issues"
     },
-    "homepage": "https://github.com/hypnodroid/hypnosound#readme",
-    "devDependencies": {
-        "eslint": "^8.57.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "live-server": "^1.2.2"
-    }
+    "homepage": "https://github.com/hypnodroid/hypnosound#readme"
 }

package/scripts/generate-barrel.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env bun
+import { readdir } from 'node:fs/promises'
+import { basename } from 'node:path'
+
+const main = async (dir = './src/audio', out = './src/audio') => {
+    const functionNamesAndPaths = (await readdir(dir, { recursive: true }))
+        .filter((file) => file.endsWith('.js'))
+        .filter((file) => file !== 'index.js')
+        .map((file) => file.replace(dir + '/', ''))
+        .map((file) => file.replace(/\\/g, '/'))
+        .map((file) => {
+            const name = basename(file, '.js')
+            const path = file.replace(/\\/g, '/')
+            return { name, path }
+        })
+    Bun.write(`${out}/index.js`, exportTemplate(functionNamesAndPaths))
+}
+const exportTemplate = (functionNamesAndPaths) => {
+    return `${functionNamesAndPaths.map((fn) => `export { default as ${fn.name} } from "./${fn.path}"`).join('\n')}
+export const AudioFeatures = ${JSON.stringify(
+        functionNamesAndPaths.map(({ name }) => name),
+        null,
+        2,
+    )}`.trim()
+}
+main()

package/src/audio/bass.js

@@ -1,34 +1,34 @@
-export default function bass(fft) {
-    const sampleRate = 44100
-    const totalSamples = fft.length
-    return calculateBassPower(fft, sampleRate, totalSamples)
-}
-
-function calculateBassPower(fft, sampleRate, totalSamples) {
-    const lowerBound = 0
-    const upperBound = 400
-    let bassEnergy = 0
-    let maxEnergy = 0
-
-    // Calculate frequency resolution
-    const frequencyResolution = sampleRate / totalSamples
-
-    for (let i = 0; i < fft.length; i++) {
-        let frequency = i * frequencyResolution
-        // 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
-        maxEnergy += power
-
-        // Isolate and accumulate bass frequencies
-        if (frequency >= lowerBound && frequency <= upperBound) {
-            bassEnergy += power
-        }
-    }
-
-    // Normalize bass energy from 0 to 1
-    let normalizedBassPower = maxEnergy > 0 ? bassEnergy / maxEnergy : 0
-    return isNaN(normalizedBassPower) ? 0 : normalizedBassPower
-}
+export default function bass(fft) {
+    const sampleRate = 44100
+    const totalSamples = fft.length
+    return calculateBassPower(fft, sampleRate, totalSamples)
+}
+
+function calculateBassPower(fft, sampleRate, totalSamples) {
+    const lowerBound = 0
+    const upperBound = 400
+    let bassEnergy = 0
+    let maxEnergy = 0
+
+    // Calculate frequency resolution
+    const frequencyResolution = sampleRate / totalSamples
+
+    for (let i = 0; i < fft.length; i++) {
+        let frequency = i * frequencyResolution
+        // 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
+        maxEnergy += power
+
+        // Isolate and accumulate bass frequencies
+        if (frequency >= lowerBound && frequency <= upperBound) {
+            bassEnergy += power
+        }
+    }
+
+    // Normalize bass energy from 0 to 1
+    let normalizedBassPower = maxEnergy > 0 ? bassEnergy / maxEnergy : 0
+    return isNaN(normalizedBassPower) ? 0 : normalizedBassPower
+}

package/src/audio/energy.js

@@ -1,19 +1,19 @@
-export default function energy(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] / maxPossibleValue // Normalize each FFT value
-        energy += normalizedValue * normalizedValue // Sum the squares of the normalized values
-    }
-
-    // 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
-}
+export default function energy(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] / maxPossibleValue // Normalize each FFT value
+        energy += normalizedValue * normalizedValue // Sum the squares of the normalized values
+    }
+
+    // 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/index.js

@@ -1,14 +1,30 @@
-export * as energy from './energy'
-export * as spectralCentroid from './spectralCentroid'
-export * as spectralCrest from './spectralCrest'
-export * as spectralEntropy from './spectralEntropy'
-export * as spectralFlux from './spectralFlux'
-export * as spectralKurtosis from './spectralKurtosis'
-export * as spectralRolloff from './spectralRolloff'
-export * as spectralRoughness from './spectralRoughness'
-export * as spectralSkew from './spectralSkew'
-export * as spectralSpread from './spectralSpread'
-export * as pitchClass from './pitchClass'
-export * as bass from './bass'
-export * as treble from './treble'
-export * as mids from './mids'
+export { default as bass } from "./bass.js"
+export { default as energy } from "./energy.js"
+export { default as mids } from "./mids.js"
+export { default as pitchClass } from "./pitchClass.js"
+export { default as spectralCentroid } from "./spectralCentroid.js"
+export { default as spectralCrest } from "./spectralCrest.js"
+export { default as spectralEntropy } from "./spectralEntropy.js"
+export { default as spectralFlux } from "./spectralFlux.js"
+export { default as spectralKurtosis } from "./spectralKurtosis.js"
+export { default as spectralRolloff } from "./spectralRolloff.js"
+export { default as spectralRoughness } from "./spectralRoughness.js"
+export { default as spectralSkew } from "./spectralSkew.js"
+export { default as spectralSpread } from "./spectralSpread.js"
+export { default as treble } from "./treble.js"
+export const AudioFeatures = [
+  "bass",
+  "energy",
+  "mids",
+  "pitchClass",
+  "spectralCentroid",
+  "spectralCrest",
+  "spectralEntropy",
+  "spectralFlux",
+  "spectralKurtosis",
+  "spectralRolloff",
+  "spectralRoughness",
+  "spectralSkew",
+  "spectralSpread",
+  "treble"
+]

package/src/audio/mids.js

@@ -1,33 +1,33 @@
-export default function mids(fft) {
-    const sampleRate = 44100
-    const totalSamples = fft.length
-    return calculateMidPower(fft, sampleRate, totalSamples)
-}
-
-function calculateMidPower(fft, sampleRate, totalSamples) {
-    const lowerBound = 400 // 400 Hz
-    const upperBound = 4000 // 4000 Hz
-    let midEnergy = 0
-    let maxEnergy = 0
-
-    // Calculate frequency resolution
-    const frequencyResolution = sampleRate / totalSamples
-
-    for (let i = 0; i < fft.length; i++) {
-        let frequency = i * frequencyResolution
-        let magnitude = Math.abs(fft[i]) / totalSamples
-        let power = magnitude * magnitude
-
-        // Accumulate max energy for normalization
-        maxEnergy += power
-
-        // Isolate and accumulate mid frequencies
-        if (frequency >= lowerBound && frequency <= upperBound) {
-            midEnergy += power
-        }
-    }
-
-    // Normalize mid energy from 0 to 1
-    let normalizedMidPower = midEnergy / maxEnergy
-    return isNaN(normalizedMidPower) ? 0 : normalizedMidPower // Scale by 10 if needed, similar to your original function
-}
+export default function mids(fft) {
+    const sampleRate = 44100
+    const totalSamples = fft.length
+    return calculateMidPower(fft, sampleRate, totalSamples)
+}
+
+function calculateMidPower(fft, sampleRate, totalSamples) {
+    const lowerBound = 400 // 400 Hz
+    const upperBound = 4000 // 4000 Hz
+    let midEnergy = 0
+    let maxEnergy = 0
+
+    // Calculate frequency resolution
+    const frequencyResolution = sampleRate / totalSamples
+
+    for (let i = 0; i < fft.length; i++) {
+        let frequency = i * frequencyResolution
+        let magnitude = Math.abs(fft[i]) / totalSamples
+        let power = magnitude * magnitude
+
+        // Accumulate max energy for normalization
+        maxEnergy += power
+
+        // Isolate and accumulate mid frequencies
+        if (frequency >= lowerBound && frequency <= upperBound) {
+            midEnergy += power
+        }
+    }
+
+    // Normalize mid energy from 0 to 1
+    let normalizedMidPower = midEnergy / maxEnergy
+    return isNaN(normalizedMidPower) ? 0 : normalizedMidPower // Scale by 10 if needed, similar to your original function
+}

package/src/audio/pitchClass.js

@@ -1,26 +1,26 @@
-export default function pitchClass(fft, sampleRate = 44100) {
-    // Constants for the FFT processing
-    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 = 1; i < fft.length; i++) {
-        // start from 1 to skip DC offset
-        if (fft[i] > maxValue) {
-            maxValue = fft[i]
-            maxIndex = i
-        }
-    }
-    const dominantFreq = maxIndex * freqResolution
-
-    // Convert to MIDI note then to pitchClass
-    const midiNote = 69 + 12 * Math.log2(dominantFreq / 440)
-    const pitchClass = Math.round(midiNote) % 12 // round to reduce minor fluctuation effects
-
-    // Normalize to a 0-1 range
-    const normalizedpitchClass = pitchClass / 12
-
-    return isNaN(normalizedpitchClass) ? 0 : normalizedpitchClass
-}
+export default function pitchClass(fft, sampleRate = 44100) {
+    // Constants for the FFT processing
+    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 = 1; i < fft.length; i++) {
+        // start from 1 to skip DC offset
+        if (fft[i] > maxValue) {
+            maxValue = fft[i]
+            maxIndex = i
+        }
+    }
+    const dominantFreq = maxIndex * freqResolution
+
+    // Convert to MIDI note then to pitchClass
+    const midiNote = 69 + 12 * Math.log2(dominantFreq / 440)
+    const pitchClass = Math.round(midiNote) % 12 // round to reduce minor fluctuation effects
+
+    // Normalize to a 0-1 range
+    const normalizedpitchClass = pitchClass / 12
+
+    return isNaN(normalizedpitchClass) ? 0 : normalizedpitchClass
+}

package/src/audio/spectralCentroid.js

@@ -1,25 +1,25 @@
-export default function spectralCentroid(fft) {
-    const computed = calculateSpectralCentroid(fft) // Process FFT data
-    return computed * 1.5
-}
-function calculateSpectralCentroid(ampSpectrum) {
-    if (!ampSpectrum.length) return null // Early exit if the spectrum is empty
-
-    let numerator = 0
-    let denominator = 0
-
-    // Calculate the weighted sum (numerator) and the sum of the amplitudes (denominator)
-    ampSpectrum.forEach((amplitude, index) => {
-        numerator += index * amplitude
-        denominator += amplitude
-    })
-
-    // Avoid dividing by zero
-    if (denominator === 0) return null
-
-    const centroidIndex = numerator / denominator
-    // Normalize the centroid index to be between 0 and 1
-    const normalizedCentroid = centroidIndex / (ampSpectrum.length - 1)
-
-    return normalizedCentroid
-}
+export default function spectralCentroid(fft) {
+    const computed = calculateSpectralCentroid(fft) // Process FFT data
+    return computed * 1.5
+}
+function calculateSpectralCentroid(ampSpectrum) {
+    if (!ampSpectrum.length) return null // Early exit if the spectrum is empty
+
+    let numerator = 0
+    let denominator = 0
+
+    // Calculate the weighted sum (numerator) and the sum of the amplitudes (denominator)
+    ampSpectrum.forEach((amplitude, index) => {
+        numerator += index * amplitude
+        denominator += amplitude
+    })
+
+    // Avoid dividing by zero
+    if (denominator === 0) return null
+
+    const centroidIndex = numerator / denominator
+    // Normalize the centroid index to be between 0 and 1
+    const normalizedCentroid = centroidIndex / (ampSpectrum.length - 1)
+
+    return normalizedCentroid
+}