Introduction

Strike a guitar string, sing a vowel, or blow across a bottle: what comes out is a periodic sound — a pressure wave that repeats the same shape over and over. That repeating chunk is the period TT, and its reciprocal f0=1/Tf_0 = 1/T is the fundamental frequency, the pitch you hear.

The question for an algorithm is: given a short burst of raw samples, what is f0f_0? This is pitch detection, and it sits at the heart of guitar tuners, voice assistants, autotune, and MIDI transcription.

The most intuitive approach is autocorrelation: slide a copy of the signal over itself, measure how well they line up at each delay τ\tau, and look for the first strong peak after zero. When the lag τ\tau equals the period TT, a periodic signal lines up with itself almost perfectly — that peak tells you the pitch.

The idea was formalized as the YIN algorithm by Alain de Cheveigné and Hideki Kawahara (2002), who added a clever normalization that suppresses the trivial peak at τ=0\tau = 0 and makes the method robust to noise. YIN is still a standard baseline in audio processing today.

Try It

Choose a waveform shape and drag the frequency slider. The top panel draws the wave; the bottom panel plots the autocorrelation function — the self-similarity of the signal at every lag. The lag of the first strong peak after zero is the estimated period, from which the algorithm reads the musical note.

<!-- Demo layout — waveform selector, frequency slider, two canvases, result line -->
<div class="controls">
  <label>
    <span>Waveform</span>
    <select id="waveform">
      <option value="sine">Sine</option>
      <option value="sawtooth">Sawtooth</option>
      <option value="square">Square</option>
    </select>
  </label>
  <label>
    <span>Frequency: <b id="freq-val">220</b> Hz</span>
    <input id="freq-slider" type="range" min="80" max="880" value="220" step="1">
  </label>
</div>
<canvas id="wave-canvas" width="560" height="120" title="Waveform display"></canvas>
<div class="section-label">Autocorrelation</div>
<canvas id="acorr-canvas" width="560" height="140" title="Autocorrelation function — first peak after lag 0 gives the period"></canvas>
<div id="result" class="result" aria-live="polite"></div>

/* Layout and colors for the pitch-detection demo */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; background: #fff; }
.controls {
  display: flex; gap: 1rem; flex-wrap: wrap; align-items: center;
  padding: .4rem 0 .6rem; margin-bottom: .2rem;
}
label { display: flex; flex-direction: column; gap: .2rem; font-size: .85rem; color: #444; }
select, input[type=range] { font-size: .9rem; }
select { padding: .25rem .4rem; border: 1px solid #aaa; border-radius: 6px; background: #f5f7fa; }
input[type=range] { width: 200px; accent-color: #1d3557; }
canvas { display: block; width: 100%; max-width: 560px; border-radius: 8px; background: #f0f4f8; }
.section-label {
  font-size: .75rem; font-weight: 600; letter-spacing: .05em; color: #5a7088;
  text-transform: uppercase; margin: .4rem 0 .15rem;
}
.result {
  margin-top: .5rem; font-size: 1rem; font-weight: 700; min-height: 1.5em;
  color: #1d3557;
}

/* Pitch detection by autocorrelation — synthetic waveforms, no Web Audio API needed */
const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

const SR = 4410; /* synthetic sample rate (Hz) — real enough for the demo */
const FRAME = 882; /* analysis frame: 200 ms at 4410 Hz */
const MIN_LAG = Math.round(SR / 880); /* minimum lag = period at 880 Hz (highest A on guitar) */
const MAX_LAG = Math.round(SR / 80);  /* maximum lag = period at 80 Hz (below open E string) */

/* map semitone offset from A4=440 Hz to note name */
const NOTE_NAMES = ['C','C#','D','D#','E','F','F#','G','G#','A','A#','B'];
function freqToNote(f) {
  const semitones = Math.round(12 * Math.log2(f / 440));
  const midi = 69 + semitones;
  const name = NOTE_NAMES[((midi % 12) + 12) % 12];
  const octave = Math.floor(midi / 12) - 1;
  return name + octave;
}

/* generate N samples of the chosen waveform at the given frequency */
function generateWave(type, freq, n) {
  const samples = new Float64Array(n);
  const period = SR / freq;
  for (let i = 0; i < n; i++) {
    const phase = (i / period) % 1;
    if (type === 'sine') {
      samples[i] = Math.sin(2 * Math.PI * phase);
    } else if (type === 'sawtooth') {
      samples[i] = 2 * phase - 1;
    } else {
      samples[i] = phase < 0.5 ? 1 : -1; /* square wave — high or low */
    }
  }
  return samples;
}

/* compute autocorrelation r(lag) = sum x[i]*x[i+lag] / (N-lag) */
function autocorrelate(samples) {
  const n = samples.length;
  const acorr = new Float64Array(MAX_LAG + 1);
  for (let lag = 0; lag <= MAX_LAG; lag++) {
    let sum = 0;
    for (let i = 0; i < n - lag; i++) sum += samples[i] * samples[i + lag];
    acorr[lag] = sum / (n - lag);
  }
  return acorr;
}

/* find the first local peak above threshold — that is the fundamental period */
function findPeak(acorr) {
  const lag0 = acorr[0] || 1;
  const THRESHOLD = 0.3; /* normalized threshold: ignore peaks below 30% of lag-0 energy */
  for (let lag = MIN_LAG + 1; lag < MAX_LAG; lag++) {
    const norm = acorr[lag] / lag0;
    if (norm > THRESHOLD && acorr[lag] > acorr[lag - 1] && acorr[lag] >= acorr[lag + 1]) {
      /* parabolic interpolation for sub-sample period accuracy */
      const a = acorr[lag - 1], b = acorr[lag], c = acorr[lag + 1];
      const delta = (a - c) / (2 * (a - 2 * b + c));
      return SR / (lag + delta);
    }
  }
  return 0;
}

/* draw waveform on canvas (clipped to ±1 amplitude) */
function drawWave(canvas, samples) {
  const ctx = canvas.getContext('2d');
  const W = canvas.width, H = canvas.height;
  ctx.clearRect(0, 0, W, H);
  ctx.strokeStyle = '#1d3557';
  ctx.lineWidth = 1.5;
  ctx.beginPath();
  for (let i = 0; i < samples.length; i++) {
    const x = (i / samples.length) * W;
    const y = H / 2 - samples[i] * (H / 2 - 6);
    i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
  }
  ctx.stroke();
}

/* draw normalized autocorrelation curve and a marker at the detected peak */
function drawAcorr(canvas, acorr) {
  const ctx = canvas.getContext('2d');
  const W = canvas.width, H = canvas.height;
  ctx.clearRect(0, 0, W, H);
  const lag0 = acorr[0] || 1;
  const norm = lag => acorr[lag] / lag0;

  /* zero line */
  ctx.strokeStyle = '#cdd9e3';
  ctx.lineWidth = 1;
  ctx.beginPath(); ctx.moveTo(0, H / 2); ctx.lineTo(W, H / 2); ctx.stroke();

  ctx.strokeStyle = '#e63946';
  ctx.lineWidth = 1.5;
  ctx.beginPath();
  for (let lag = 0; lag <= MAX_LAG; lag++) {
    const x = (lag / MAX_LAG) * W;
    const y = H / 2 - norm(lag) * (H / 2 - 8);
    lag === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
  }
  ctx.stroke();

  /* vertical dashed line at detected period */
  const peakFreq = findPeak(acorr);
  if (peakFreq > 0) {
    const peakLag = Math.round(SR / peakFreq);
    const px = (peakLag / MAX_LAG) * W;
    ctx.strokeStyle = '#0a7d33';
    ctx.lineWidth = 1.5;
    ctx.setLineDash([4, 3]);
    ctx.beginPath(); ctx.moveTo(px, 0); ctx.lineTo(px, H); ctx.stroke();
    ctx.setLineDash([]);
  }
}

function update() {
  const type = document.getElementById('waveform').value;
  const freq = parseFloat(document.getElementById('freq-slider').value);
  document.getElementById('freq-val').textContent = freq;

  const samples = generateWave(type, freq, FRAME);
  const acorr = autocorrelate(samples);
  const detectedFreq = findPeak(acorr);
  const note = detectedFreq > 0 ? freqToNote(detectedFreq) : '—';

  drawWave(document.getElementById('wave-canvas'), samples);
  drawAcorr(document.getElementById('acorr-canvas'), acorr);

  const resultEl = document.getElementById('result');
  if (detectedFreq > 0) {
    resultEl.textContent = i18nFmt('Detected: %freq% Hz — note %note%', { freq: detectedFreq.toFixed(1), note: note });
  } else {
    resultEl.textContent = 'No pitch detected';
  }
}

document.getElementById('freq-slider').addEventListener('input', update);
document.getElementById('waveform').addEventListener('change', update);
update(); /* first render on page load */
Result
Console

Notice how a pure sine wave produces a smooth, clean autocorrelation, while a sawtooth or square wave (rich in harmonics) creates a more jagged curve — yet the first peak still lands at the true period. This robustness is why autocorrelation beats simply hunting for the loudest frequency in a fast Fourier transform: harmonics can easily fool a spectrum peak-picker, but they reinforce the autocorrelation peak at the fundamental.

The Real Complexity

How expensive is autocorrelation?

  • Naive implementation: for each lag τ\tau from 00 to N−1N-1 you compute a dot product over NN samples — total cost O(N2)O(N^{2}) per frame. For a 44 100 Hz signal with 20 ms frames (N≈882N \approx 882) that is around 780 000 multiplications per frame, 44 frames per second — feasible, but tight on embedded hardware.
  • FFT acceleration: the autocorrelation of a signal equals the inverse FFT of its power spectrum (Wiener–Khinchin theorem). Two FFTs and one pointwise multiply drop the cost to O(Nlog⁡N)O(N \log N), giving a 30–50× speedup at typical frame sizes.
  • YIN's normalization: raw autocorrelation always peaks at τ=0\tau = 0 (a signal matches itself perfectly with no shift). YIN replaces it with the cumulative mean normalized difference function — a running normalization that sets the τ=0\tau = 0 value to 1 and suppresses harmonic sub-multiples of the true period, so the algorithm can confidently pick the first dip below a threshold rather than the highest peak.
  • Polyphony is hard: autocorrelation finds one period. When two notes play together, the combined autocorrelation smears across both periods. Multi-pitch estimation is an open research problem that still does not have a universally accepted solution.

The solved part — single-pitch detection — is fast, robust, and well-understood. The unsolved part — polyphony — is where the field is still active.

Where It Matters

Pitch detection is everywhere a machine needs to understand musical or vocal sound:

  • Guitar tuners and instrument apps: every chromatic tuner running on a phone uses autocorrelation (or a YIN variant) to name the note in real time.
  • Autotune and pitch correction: the algorithm first detects pitch, then shifts the signal's phase-vocoder representation to the nearest semitone.
  • Voice assistants and speech synthesis: fundamental frequency contours (prosody) carry emotion and sentence structure; extracting f0f_0 is a preprocessing step in almost every speech pipeline.
  • MIDI transcription: turning a live recording into sheet music requires knowing which note was played at every moment — autocorrelation provides the f0f_0 estimate, which is then quantized to the nearest MIDI pitch.
  • Medical acoustics: tracking the f0f_0 of a patient's voice over time can reveal vocal-fold pathologies; a deviant autocorrelation peak signals that something is wrong before a clinician can hear it.

The same self-similarity idea also appears in video (motion estimation by block matching is a 2-D autocorrelation), radar (range-Doppler processing), and any domain where "how does this signal relate to a shifted copy of itself?" is a meaningful question.

Conclusion

Pitch detection by autocorrelation rests on a beautiful fact: a periodic signal is its own best match when you shift it by exactly one period. Slide, correlate, find the first strong peak — and you have the pitch.

YIN's refinement (cumulative normalized difference, threshold at 0.1) made this robust enough for real-world noisy audio, and the FFT-acceleration made it fast enough to run in real time on modest hardware. Single-pitch detection is a solved problem.

What remains open is the polyphonic case: when multiple notes overlap, untangling their individual periods is hard in a way that autocorrelation alone cannot solve. That boundary — between what one self-similarity function can hear and what it cannot — is a microcosm of the broader story of algorithms and their limits, the theme that runs through every article on this site.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/pitch-detection-autocorrelation/Content licensed under CC BY-NC 4.0.