hypnosound 1.8.1 → 1.10.2

package/.github/workflows/publish.yml

@@ -0,0 +1,44 @@
+name: Publish to npm
+
+on:
+  push:
+    branches: [main]
+    paths: [package.json]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org
+
+      - name: Update npm
+        run: npm install -g npm@latest
+
+      - name: Check if version changed
+        id: version-check
+        run: |
+          LOCAL_VERSION=$(node -p "require('./package.json').version")
+          NPM_VERSION=$(npm view hypnosound version 2>/dev/null || echo "0.0.0")
+          echo "local=$LOCAL_VERSION" >> "$GITHUB_OUTPUT"
+          echo "npm=$NPM_VERSION" >> "$GITHUB_OUTPUT"
+          if [ "$LOCAL_VERSION" != "$NPM_VERSION" ]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Publish
+        if: steps.version-check.outputs.changed == 'true'
+        run: npm publish --provenance --access public
+
+      - name: Skip
+        if: steps.version-check.outputs.changed == 'false'
+        run: echo "Version ${{ steps.version-check.outputs.local }} already published, skipping"

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.1",
+    "version": "1.10.2",
     "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/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/utils/calculateStats.js

@@ -1,4 +1,4 @@
-export const StatTypes = ['normalized', 'mean', 'median', 'standardDeviation', 'zScore', 'min', 'max']
+export const StatTypes = ['normalized', 'mean', 'median', 'standardDeviation', 'zScore', 'min', 'max', 'slope', 'intercept', 'rSquared']
 
 const erf = (x) => {
     const a1 = 0.254829592
@@ -150,6 +150,44 @@ export const makeCalculateStats = (historySize = 500) => {
         return lowerHalf[0]
     }
 
+    // Calculate linear regression using least squares method
+    // Uses indices 0 to n-1 as x values, queue values as y values
+    const calculateLinearRegression = (mean) => {
+        const n = queue.length
+        if (n < 2) return { slope: 0, intercept: mean, rSquared: 0 }
+
+        // For x = 0, 1, 2, ..., n-1:
+        // sumX = n*(n-1)/2
+        // sumXX = n*(n-1)*(2n-1)/6
+        const sumX = (n * (n - 1)) / 2
+        const sumXX = (n * (n - 1) * (2 * n - 1)) / 6
+
+        // Calculate sumXY = sum of (i * queue[i])
+        let sumXYCalc = 0
+        for (let i = 0; i < n; i++) {
+            sumXYCalc += i * queue[i]
+        }
+
+        const denominator = n * sumXX - sumX * sumX
+        if (denominator === 0) return { slope: 0, intercept: mean, rSquared: 0 }
+
+        const slope = (n * sumXYCalc - sumX * sum) / denominator
+        const intercept = (sum - slope * sumX) / n
+
+        // Calculate R-squared (coefficient of determination)
+        let ssRes = 0  // Sum of squared residuals
+        let ssTot = 0  // Total sum of squares
+        for (let i = 0; i < n; i++) {
+            const predicted = slope * i + intercept
+            ssRes += (queue[i] - predicted) ** 2
+            ssTot += (queue[i] - mean) ** 2
+        }
+
+        const rSquared = ssTot === 0 ? 1 : 1 - ssRes / ssTot
+
+        return { slope, intercept, rSquared }
+    }
+
     const calculate = (value) => {
         if (typeof value !== 'number' || isNaN(value)) throw new Error('Input must be a valid number')
 
@@ -175,6 +213,8 @@ export const makeCalculateStats = (historySize = 500) => {
         const min = minQueue.peek() || 0
         const max = maxQueue.peek() || 0
 
+        const regression = calculateLinearRegression(mean)
+
         if (max === min) {
             return {
                 current: value,
@@ -185,6 +225,9 @@ export const makeCalculateStats = (historySize = 500) => {
                 mean,
                 min,
                 max,
+                slope: regression.slope,
+                intercept: regression.intercept,
+                rSquared: regression.rSquared,
             }
         }
 
@@ -198,6 +241,9 @@ export const makeCalculateStats = (historySize = 500) => {
             mean,
             min,
             max,
+            slope: regression.slope,
+            intercept: regression.intercept,
+            rSquared: regression.rSquared,
         }
     }