Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344// 🎵 Audio Analyzer - Shared module for consistent audio analysis// This module provides the exact same algorithms used in speaker.mjs (AudioWorklet)// so that both the AC runtime and kidlisp.com editor produce identical values.//// Usage in main thread (kidlisp.com editor):// const analyzer = new AudioAnalyzer(audioContext.sampleRate);// const audioData = analyzer.analyzeAudioData(float32Array);// // audioData = { amp, leftAmp, rightAmp, beat, kick, frequencies }//// The speaker.mjs AudioWorklet uses these same algorithms internally.
export const AUDIO_ANALYZER_VERSION = "1.0.0";
// Configuration constants (same as speaker.mjs)export const FFT_SIZE = 512;export const ENERGY_HISTORY_SIZE = 20;export const BEAT_SENSITIVITY = 1.15;export const BEAT_COOLDOWN = 0.08; // seconds
// Frequency band definitions (same as speaker.mjs)export const FREQUENCY_BANDS = [ { name: 'subBass', min: 20, max: 100 }, { name: 'lowMid', min: 100, max: 400 }, { name: 'mid', min: 400, max: 1000 }, { name: 'highMid', min: 1000, max: 2500 }, { name: 'presence', min: 2500, max: 5000 }, { name: 'treble', min: 5000, max: 10000 }, { name: 'air', min: 10000, max: 16000 }, { name: 'ultra', min: 16000, max: 20000 }];
/** * Iterative FFT implementation - same as speaker.mjs * @param {Float32Array|number[]} buffer - Audio samples * @returns {Array<{real: number, imag: number}>} Complex FFT result */export function fft(buffer) { const N = buffer.length; if (N <= 1) return Array.from(buffer).map(x => ({ real: x, imag: 0 })); // Ensure power of 2 and use smaller size for consistency const powerOf2 = Math.min(FFT_SIZE, Math.pow(2, Math.floor(Math.log2(N)))); const input = Array.from(buffer).slice(0, powerOf2); // Use iterative FFT instead of recursive for better performance const result = input.map(x => ({ real: x, imag: 0 })); // Bit-reverse permutation for (let i = 0; i < powerOf2; i++) { let j = 0; for (let k = 0; k < Math.log2(powerOf2); k++) { j = (j << 1) | ((i >> k) & 1); } if (j > i) { [result[i], result[j]] = [result[j], result[i]]; } } // Iterative FFT for (let len = 2; len <= powerOf2; len *= 2) { const w = { real: Math.cos(-2 * Math.PI / len), imag: Math.sin(-2 * Math.PI / len) }; for (let i = 0; i < powerOf2; i += len) { let wn = { real: 1, imag: 0 }; for (let j = 0; j < len / 2; j++) { const u = result[i + j]; const v = { real: result[i + j + len / 2].real * wn.real - result[i + j + len / 2].imag * wn.imag, imag: result[i + j + len / 2].real * wn.imag + result[i + j + len / 2].imag * wn.real }; result[i + j] = { real: u.real + v.real, imag: u.imag + v.imag }; result[i + j + len / 2] = { real: u.real - v.real, imag: u.imag - v.imag }; const temp = { real: wn.real * w.real - wn.imag * w.imag, imag: wn.real * w.imag + wn.imag * w.real }; wn = temp; } } } return result;}
/** * Analyze frequencies and return structured frequency bands - same as speaker.mjs * @param {Float32Array|number[]} buffer - Audio samples (should be FFT_SIZE length) * @param {number} sampleRate - Audio sample rate * @returns {Array<{name: string, frequency: {min: number, max: number}, amplitude: number}>} */export function analyzeFrequencies(buffer, sampleRate) { if (buffer.length < FFT_SIZE) return []; // Simplified windowing - use rectangular window for consistency const windowedBuffer = Array.from(buffer).slice(0, FFT_SIZE); // Perform FFT const fftResult = fft(windowedBuffer); // Calculate magnitude spectrum const magnitudes = fftResult.map(complex => Math.sqrt(complex.real * complex.real + complex.imag * complex.imag) ); // Calculate bin frequency resolution const binFreq = sampleRate / FFT_SIZE; // Analyze each frequency band return FREQUENCY_BANDS.map(band => { const startBin = Math.floor(band.min / binFreq); const endBin = Math.min(Math.floor(band.max / binFreq), magnitudes.length / 2); let sum = 0; let count = 0; for (let i = startBin; i < endBin; i++) { sum += magnitudes[i]; count++; } const amplitude = count > 0 ? sum / count : 0; // Apply power scaling for better dynamic range (same as speaker.mjs) let scaledAmplitude = amplitude; if (scaledAmplitude > 0) { scaledAmplitude = Math.pow(scaledAmplitude, 0.7); } return { name: band.name, frequency: { min: band.min, max: band.max }, amplitude: Math.min(0.9, scaledAmplitude), // 90% clamp binRange: { start: startBin, end: endBin } }; });}
/** * Calculate peak amplitude from audio samples * @param {Float32Array|number[]} samples - Audio samples * @returns {number} Peak amplitude (0-1) */export function calculateAmplitude(samples) { let peak = 0; for (let i = 0; i < samples.length; i++) { const abs = Math.abs(samples[i]); if (abs > peak) peak = abs; } return peak;}
/** * Audio Analyzer class - maintains state for beat detection * Provides the same analysis as speaker.mjs AudioWorkletProcessor */export class AudioAnalyzer { #sampleRate; #fftBufferLeft = []; #fftBufferRight = []; #energyHistory = []; #energyHistorySize = ENERGY_HISTORY_SIZE; #beatSensitivity = BEAT_SENSITIVITY; #beatCooldown = BEAT_COOLDOWN; #lastBeatTime = 0; #currentBeat = false; #beatStrength = 0; #adaptiveThreshold = BEAT_SENSITIVITY; #energyVariance = 0; #recentEnergyPeaks = []; #lastAnalysisTime = 0; constructor(sampleRate = 44100) { this.#sampleRate = sampleRate; } /** * Get the current time in seconds (for beat detection timing) * Override this if you need custom timing */ getCurrentTime() { return performance.now() / 1000; } /** * Analyze stereo audio data and return all audio parameters * @param {Float32Array|number[]} leftChannel - Left channel samples * @param {Float32Array|number[]|null} rightChannel - Right channel samples (optional, defaults to left) * @returns {{ * amp: number, * leftAmp: number, * rightAmp: number, * beat: number, * kick: number, * frequencies: {left: Array, right: Array}, * beatStrength: number * }} */ analyze(leftChannel, rightChannel = null) { const currentTime = this.getCurrentTime(); rightChannel = rightChannel || leftChannel; // Calculate amplitudes (peak detection, same as speaker.mjs) const leftAmp = calculateAmplitude(leftChannel); const rightAmp = calculateAmplitude(rightChannel); const amp = (leftAmp + rightAmp) / 2; // Add samples to FFT buffers this.#fftBufferLeft.push(...leftChannel); this.#fftBufferRight.push(...rightChannel); // Keep buffer size manageable if (this.#fftBufferLeft.length > FFT_SIZE) { this.#fftBufferLeft = this.#fftBufferLeft.slice(-FFT_SIZE); this.#fftBufferRight = this.#fftBufferRight.slice(-FFT_SIZE); } // Analyze frequencies let frequencyBandsLeft = []; let frequencyBandsRight = []; if (this.#fftBufferLeft.length >= FFT_SIZE) { frequencyBandsLeft = analyzeFrequencies(this.#fftBufferLeft, this.#sampleRate); frequencyBandsRight = analyzeFrequencies(this.#fftBufferRight, this.#sampleRate); } // Beat detection (same algorithm as speaker.mjs) this.#detectBeats(this.#fftBufferLeft, currentTime); // Scale amplitudes to 0-10 range for KidLisp (same as AC runtime) const scaledAmp = amp * 10; const scaledLeftAmp = leftAmp * 10; const scaledRightAmp = rightAmp * 10; return { amp: scaledAmp, leftAmp: scaledLeftAmp, rightAmp: scaledRightAmp, beat: this.#currentBeat ? 1 : 0, kick: this.#currentBeat ? 1 : 0, // alias for beat frequencies: { left: frequencyBandsLeft, right: frequencyBandsRight }, beatStrength: this.#beatStrength }; } /** * Beat detection using energy-based onset detection - same as speaker.mjs * @private */ #detectBeats(buffer, currentTime) { if (buffer.length < FFT_SIZE) return; // Calculate current energy (sum of squares in frequency domain) const fftData = fft(buffer); let currentEnergy = 0; // Focus on lower frequencies for beat detection (bass/kick drums) const bassEndBin = Math.floor(250 * FFT_SIZE / this.#sampleRate); for (let i = 1; i < Math.min(bassEndBin, fftData.length / 2); i++) { const complex = fftData[i] || { real: 0, imag: 0 }; currentEnergy += complex.real * complex.real + complex.imag * complex.imag; } // Normalize energy currentEnergy = Math.sqrt(currentEnergy / bassEndBin); // Add to energy history this.#energyHistory.push(currentEnergy); if (this.#energyHistory.length > this.#energyHistorySize) { this.#energyHistory.shift(); } // Clear expired beat flag (beat lasts 50ms) if (this.#currentBeat && currentTime - this.#lastBeatTime > 0.05) { this.#currentBeat = false; this.#beatStrength = 0; } // Need enough history for comparison if (this.#energyHistory.length < this.#energyHistorySize) return; // Calculate average energy over recent history const avgEnergy = this.#energyHistory.reduce((sum, e) => sum + e, 0) / this.#energyHistory.length; // Calculate energy variance for adaptive sensitivity const variance = this.#energyHistory.reduce((sum, e) => sum + Math.pow(e - avgEnergy, 2), 0) / this.#energyHistory.length; this.#energyVariance = Math.sqrt(variance); // Track recent energy peaks for adaptive threshold if (currentEnergy > avgEnergy) { this.#recentEnergyPeaks.push(currentEnergy); if (this.#recentEnergyPeaks.length > 20) { this.#recentEnergyPeaks.shift(); } } // Adaptive threshold based on recent activity and variance let adaptiveMultiplier = 1.0; if (this.#energyVariance > 0 && avgEnergy > 0) { const normalizedVariance = Math.min(this.#energyVariance / 50, 1.0); if (avgEnergy > 20) { // Loud music: be much more sensitive adaptiveMultiplier = Math.max(0.4, 0.8 - normalizedVariance * 0.3); } else if (normalizedVariance > 0.3) { // Dynamic music: moderately more sensitive adaptiveMultiplier = Math.max(0.7, 1.1 - normalizedVariance * 0.4); } else { // Quiet/steady music: standard sensitivity adaptiveMultiplier = 1.0 + normalizedVariance * 0.2; } } this.#adaptiveThreshold = this.#beatSensitivity * adaptiveMultiplier; // Time-based sensitivity boost const timeSinceLastBeat = currentTime - this.#lastBeatTime; let timeBasedSensitivity = 1.0; if (timeSinceLastBeat > 0.3) { timeBasedSensitivity = 1.0 + Math.min(0.4, (timeSinceLastBeat - 0.3) * 0.8); } const finalThreshold = this.#adaptiveThreshold / timeBasedSensitivity; const energyRatio = avgEnergy > 0 ? currentEnergy / avgEnergy : 0; // Detect beat if (energyRatio > finalThreshold && timeSinceLastBeat > this.#beatCooldown) { this.#currentBeat = true; this.#beatStrength = Math.min(1.0, (energyRatio - finalThreshold) / 2.0); this.#lastBeatTime = currentTime; } } /** * Reset the analyzer state */ reset() { this.#fftBufferLeft = []; this.#fftBufferRight = []; this.#energyHistory = []; this.#lastBeatTime = 0; this.#currentBeat = false; this.#beatStrength = 0; this.#recentEnergyPeaks = []; }}
export default AudioAnalyzer;