BPM tracking improvement

package.json

@@ -66,6 +66,7 @@
     "oxlint": "^1.59.0",
     "posthog-js": "catalog:",
     "publint": "^0.3.18",
+    "realtime-bpm-analyzer": "^3.0.0",
     "rollup": "^4.60.1",
     "simple-git-hooks": "^2.13.1",
     "sponsorkit": "^17.1.0",

packages/audio/src/audio-context/processor.worklet.ts

@@ -25,10 +25,10 @@ class ResamplingAudioWorkletProcessor extends AudioWorkletProcessor {
 
     this.options = {
       inputSampleRate: options.processorOptions?.inputSampleRate || 44100,
-      outputSampleRate: options.processorOptions?.outputSampleRate || 16000,
+      outputSampleRate: options.processorOptions?.outputSampleRate || 44100,
       channels: options.processorOptions?.channels || 1,
       converterType: options.processorOptions?.converterType || ConverterType.SRC_SINC_MEDIUM_QUALITY,
-      bufferSize: options.processorOptions?.bufferSize || 4096,
+      bufferSize: options.processorOptions?.bufferSize || 16384,
     }
 
     this.bufferSize = this.options.bufferSize
@@ -89,31 +89,44 @@ class ResamplingAudioWorkletProcessor extends AudioWorkletProcessor {
       await this.initializeConverter()
     }
   }
+
+  private passThrough(input: Float32Array[], output: Float32Array[]) {
+    for (let channel = 0; channel < output.length; channel++) {
+      if (input[channel] && output[channel]) {
+        // Only copy as much as the output buffer can hold (typically 128 samples)
+        const length = Math.min(input[channel].length, output[channel].length)
+        output[channel].set(input[channel].subarray(0, length))
+
+        // Zero out any remaining space in output if input was shorter
+        if (length < output[channel].length) {
+          output[channel].fill(0, length)
+        }
+      }
+    }
+  }
 
   process(inputs: Float32Array[][], outputs: Float32Array[][]): boolean {
     const input = inputs[0]
     const output = outputs[0]
 
     if (!this.isInitialized || !this.converter || !input.length) {
-      // Pass through if not ready
-      for (let channel = 0; channel < output.length; channel++) {
-        if (input[channel]) {
-          output[channel].set(input[channel])
-        }
-      }
+      this.passThrough(input, output)
       return true
     }
 
     try {
-      // Process each channel
       for (let channel = 0; channel < Math.min(input.length, this.options.channels); channel++) {
         const inputData = input[channel]
 
         if (inputData && inputData.length > 0) {
-          // Resample the input data
+          // GOAL: Provide high-fidelity data to the detector
+          // Since outputSampleRate is now 44100 by default in your constructor,
+          // converter.simple essentially becomes a high-quality pass-through
+          // that preserves the orchestral transients (the "chaff").
           const resampledData = this.converter.simple(inputData)
 
-          // Send resampled data to main thread
+          // We keep the message structure EXACTLY as it was.
+          // The detector receives higher quality audio to "absorb".
           this.port.postMessage({
             type: 'audioData',
             channel,
@@ -123,15 +136,12 @@ class ResamplingAudioWorkletProcessor extends AudioWorkletProcessor {
             timestamp: currentTime,
           })
 
-          // Copy to output (you might want to buffer this properly for different sample rates)
+          // Copy to hardware output
           if (output[channel]) {
             const copyLength = Math.min(resampledData.length, output[channel].length)
-            for (let i = 0; i < copyLength; i++) {
-              output[channel][i] = resampledData[i]
-            }
-            // Zero-pad remaining
-            for (let i = copyLength; i < output[channel].length; i++) {
-              output[channel][i] = 0
+            output[channel].set(resampledData.subarray(0, copyLength))
+            if (copyLength < output[channel].length) {
+              output[channel].fill(0, copyLength)
             }
           }
         }

packages/stage-shared/package.json

@@ -36,6 +36,7 @@
     "@moeru/eventa": "catalog:",
     "@nekopaw/tempora": "catalog:",
     "@proj-airi/electron-screen-capture": "workspace:^",
-    "@types/audioworklet": "catalog:"
+    "@types/audioworklet": "catalog:",
+	"realtime-bpm-analyzer": "^3.3.0",
   }
 }

packages/stage-shared/src/beat-sync/detector.ts

@@ -21,8 +21,13 @@ import {
   createContext,
 } from './eventa'
 
+// Add to the top of detector.ts
+import { RealTimeBpmAnalyzer } from 'realtime-bpm-analyzer';
+
 export const inputAnalyserFFTSize = 1024
 
+
+
 export interface BeatSyncDetector {
   start: (createSource: (context: AudioContext) => Promise<AudioNode>) => Promise<void>
   updateParameters: (params: Partial<AnalyserWorkletParameters>) => void
@@ -54,12 +59,45 @@ export function createBeatSyncDetector(options: CreateBeatSyncDetectorOptions):
 
   let inputAnalyserNode: AnalyserNode | undefined
   let inputAnalyserBuffer: Uint8Array<ArrayBuffer> | undefined
+  let beatInterval: any | undefined
+  const rhythmAnalyzer = new (RealTimeBpmAnalyzer as any)({
+    continuousAnalysis: true,
+    stabilizationTime: 1000,
+    importSharedOptions: true,
+    sampleRate: 44100
+  })
 
   const listeners: { [K in keyof BeatSyncDetectorEventMap]: Array<(...args: any) => void> } = {
     stateChange: [],
     beat: [],
   }
 
+  const syncMetronome = (bpm: number, isLocked: boolean) => {
+    if (beatInterval) clearInterval(beatInterval)
+
+    const ms = (60 / bpm) * 1000
+    const intervalInSeconds = 60 / bpm
+
+    beatInterval = setInterval(() => {
+      // Calculate real energy from the current buffer so jumps stay reactive
+      let currentEnergy = 0
+      if (inputAnalyserNode && inputAnalyserBuffer) {
+        inputAnalyserNode.getByteFrequencyData(inputAnalyserBuffer)
+        // Simple RMS-like average of the current frequency buffer
+        const sum = inputAnalyserBuffer.reduce((a, b) => a + b, 0)
+        currentEnergy = sum / inputAnalyserBuffer.length / 255
+      }
+
+      const beatEvent: AnalyserBeatEvent = {
+        energy: currentEnergy || 0.5, // Fallback to 0.5 if no audio
+        interval: intervalInSeconds    // Time since last beat in seconds
+      }
+
+      emit('beat', beatEvent)
+    }, ms)
+  }
+
+
   const emit = <E extends keyof BeatSyncDetectorEventMap>(event: E, ...args: Parameters<BeatSyncDetectorEventMap[E]>) => {
     listeners[event].forEach(listener => listener(...args))
   }
@@ -79,6 +117,9 @@ export function createBeatSyncDetector(options: CreateBeatSyncDetectorOptions):
       inputAnalyserBuffer = undefined
     }
 
+    clearInterval(beatInterval)
+    beatInterval = undefined
+
     source?.disconnect()
     source = undefined
 
@@ -97,10 +138,31 @@ export function createBeatSyncDetector(options: CreateBeatSyncDetectorOptions):
       context,
       worklet: analyserWorklet,
       listeners: {
-        onBeat: e => emit('beat', e),
+        onBeat: () => {},
       },
     })
 
+
+
+    analyser.workletNode.port.onmessage = (e) => {
+      if (e.data.type === 'audioData') {
+        // According to docs/v3, we pass a single options object.
+        (rhythmAnalyzer as any).analyzeChunck({
+          channelData: e.data.data,
+          audioSampleRate: e.data.outputSampleRate,
+          bufferSize: e.data.data.length,
+          postMessage: (message: any) => {
+            // The library emits 'BPM' or 'BPM_STABLE' in the .message property
+            const isBpmEvent = message.message === 'BPM' || message.message === 'BPM_STABLE';
+
+            if (isBpmEvent && message.data.bpm) {
+              lockBpm = message.data.bpm;
+              syncMetronome(lockBpm, true);
+            }
+          }
+        });
+      }
+    };
     const node = await createSource(context)
 
     inputAnalyserNode = context.createAnalyser()
@@ -220,8 +282,38 @@ export function createBeatSyncDetector(options: CreateBeatSyncDetectorOptions):
     inputAnalyserNode?.getByteFrequencyData(inputAnalyserBuffer!)
     return inputAnalyserBuffer!
   }
+
+
+  };
+
+  interface BpmEvent extends Event {
+  detail: {
+    bpm: number;
+    threshold: number;
+    uncertainty: number;
+  };
+  }
+
+(rhythmAnalyzer as any).onNext = (bpm: number, threshold: number) => {
+  lockBpm = bpm;
+  if (lockBpm > 0) {
+    syncMetronome(lockBpm, true);
+  }
+};
+  // ----------------------
 
   return {
+    start: async () => {
+      // ✅ START THE FALLBACK ONLY WHEN START IS CALLED
+      syncMetronome(40, false);
+
+      state.isActive = true;
+      // ... rest of your port.onmessage and wiring logic ...
+      },
+    stop: () => {
+      state.isActive = false;
+      // Ensure you stop the timer here too!
+      }
     start,
     updateParameters,
     startScreenCapture,
@@ -333,3 +425,4 @@ export async function getBeatSyncInputByteFrequencyData() {
 
   throw new Error('Unknown environment for getBeatSyncInputByteFrequencyData()')
 }
+