|
|
function startPitchDetection(callback) {
|
|
|
// Check for browser support
|
|
|
if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
|
|
|
console.error("getUserMedia is not supported in this browser.");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// Request access to the microphone
|
|
|
//navigator.mediaDevices.getUserMedia({ audio: true })
|
|
|
navigator.mediaDevices.getUserMedia({
|
|
|
audio: {
|
|
|
echoCancellation: false,
|
|
|
noiseSuppression: false,
|
|
|
autoGainControl: false
|
|
|
}
|
|
|
})
|
|
|
.then(stream => {
|
|
|
// Create an audio context and an analyser node
|
|
|
const audioContext = new (window.AudioContext || window.webkitAudioContext)();
|
|
|
const analyser = audioContext.createAnalyser();
|
|
|
analyser.fftSize = 2048; // Set FFT size; higher values offer more precision but more latency
|
|
|
|
|
|
// Connect the microphone stream to the analyser node
|
|
|
const source = audioContext.createMediaStreamSource(stream);
|
|
|
source.connect(analyser);
|
|
|
|
|
|
// Create a buffer to hold the time domain data
|
|
|
const bufferLength = analyser.fftSize;
|
|
|
const buffer = new Float32Array(bufferLength);
|
|
|
|
|
|
/**
|
|
|
* Autocorrelation algorithm to estimate pitch from the audio buffer.
|
|
|
* Returns the estimated pitch in Hz, or -1 if no pitch is detected.
|
|
|
*/
|
|
|
function autoCorrelate(buf, sampleRate) {
|
|
|
const SIZE = buf.length;
|
|
|
let rms = 0;
|
|
|
|
|
|
// Compute Root Mean Square (RMS) to check if there's enough signal
|
|
|
for (let i = 0; i < SIZE; i++) {
|
|
|
const val = buf[i];
|
|
|
rms += val * val;
|
|
|
}
|
|
|
rms = Math.sqrt(rms / SIZE);
|
|
|
if (rms < 0.01) // Signal too weak – likely silence
|
|
|
return -1;
|
|
|
|
|
|
// Trim the buffer to remove noise at the beginning and end
|
|
|
let r1 = 0, r2 = SIZE - 1;
|
|
|
for (let i = 0; i < SIZE; i++) {
|
|
|
if (Math.abs(buf[i]) < 0.2) { r1 = i; break; }
|
|
|
}
|
|
|
for (let i = 1; i < SIZE; i++) {
|
|
|
if (Math.abs(buf[SIZE - i]) < 0.2) { r2 = SIZE - i; break; }
|
|
|
}
|
|
|
const trimmedBuffer = buf.slice(r1, r2);
|
|
|
const trimmedSize = trimmedBuffer.length;
|
|
|
|
|
|
// Calculate the autocorrelation of the trimmed buffer
|
|
|
const correlations = new Array(trimmedSize).fill(0);
|
|
|
for (let lag = 0; lag < trimmedSize; lag++) {
|
|
|
for (let i = 0; i < trimmedSize - lag; i++) {
|
|
|
correlations[lag] += trimmedBuffer[i] * trimmedBuffer[i + lag];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Find the first dip in the autocorrelation – skip lags before this point
|
|
|
let d = 0;
|
|
|
while (d < correlations.length - 1 && correlations[d] > correlations[d + 1]) {
|
|
|
d++;
|
|
|
}
|
|
|
|
|
|
// Search for the peak correlation after the dip
|
|
|
let maxVal = -1, maxPos = -1;
|
|
|
for (let i = d; i < correlations.length; i++) {
|
|
|
if (correlations[i] > maxVal) {
|
|
|
maxVal = correlations[i];
|
|
|
maxPos = i;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Parabolic interpolation for a more accurate peak estimate
|
|
|
let T0 = maxPos;
|
|
|
if (T0 > 0 && T0 < correlations.length - 1) {
|
|
|
const x1 = correlations[T0 - 1];
|
|
|
const x2 = correlations[T0];
|
|
|
const x3 = correlations[T0 + 1];
|
|
|
const a = (x1 + x3 - 2 * x2) / 2;
|
|
|
const b = (x3 - x1) / 2;
|
|
|
if (a !== 0) {
|
|
|
T0 = T0 - b / (2 * a);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Convert lag to frequency
|
|
|
const pitch = sampleRate / T0;
|
|
|
return pitch;
|
|
|
}
|
|
|
|
|
|
// Continuously update and detect pitch
|
|
|
function updatePitch() {
|
|
|
// Get the latest time-domain data
|
|
|
analyser.getFloatTimeDomainData(buffer);
|
|
|
// Estimate pitch using our autocorrelation function
|
|
|
const pitch = autoCorrelate(buffer, audioContext.sampleRate);
|
|
|
// Pass the detected pitch (in Hz) to the provided callback
|
|
|
callback(pitch);
|
|
|
// Continue the update loop
|
|
|
requestAnimationFrame(updatePitch);
|
|
|
}
|
|
|
|
|
|
updatePitch();
|
|
|
})
|
|
|
.catch(err => {
|
|
|
console.error("Error accessing the microphone: ", err);
|
|
|
});
|
|
|
}
|
