hypnosound 1.2.1 → 1.3.0

package/index.html

@@ -19,7 +19,7 @@
                 const analyser = audioContext.createAnalyser();
 
                 source.connect(analyser);
-                analyser.fftSize = 32768; // Or whatever size you need
+                analyser.fftSize = 32768/2; // Or whatever size you need
                 analyser.smoothingTimeConstant = 0
                 const bufferLength = analyser.frequencyBinCount;
                 const dataArray = new Uint8Array(bufferLength);
@@ -30,18 +30,19 @@
                     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),
-                    });
+                    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),
+                    a.pitchClass(dataArray),
+                    );
                 };
 
                 draw();

package/index.js

@@ -10,7 +10,7 @@ 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'
 class AudioProcessor {
     constructor() {
         // aah, state management
@@ -37,6 +37,8 @@ class AudioProcessor {
         this.statCalculators.spectralRoughness = makeCalculateStats()
 
         this.statCalculators.spectralSpread = makeCalculateStats()
+
+        this.statCalculators.pitchClass = makeCalculateStats()
     }
 
     energy = (fft) => {
@@ -108,6 +110,13 @@ class AudioProcessor {
         const stats = this.statCalculators.spectralSpread(value)
         return { value, stats }
     }
+
+    pitchClass = (fft) => {
+        const windowedFft = applyKaiserWindow(fft)
+        const value = pitchClass(windowedFft)
+        const stats = this.statCalculators.pitchClass(value)
+        return { value, stats }
+    }
 }
 export default AudioProcessor
 export {

package/package.json

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

package/src/audio/index.js

@@ -8,3 +8,4 @@ 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'

package/src/audio/pitchClass.js

@@ -0,0 +1,26 @@
+export default function pitchClass(fft) {
+  // 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 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++) {
+    if (fft[i] > maxValue) {
+      maxValue = fft[i];
+      maxIndex = i;
+    }
+  }
+  const dominantFreq = maxIndex * freqResolution;
+
+  // Convert to MIDI note then to pitchClass class
+  const midiNote = 69 + 12 * Math.log2(dominantFreq / 440);
+  const pitchClass = midiNote % 12;
+
+  // Normalize to a 0-1 range
+  const normalizedpitchClass = pitchClass / 12;
+
+  return normalizedpitchClass;
+}