Introduction

You have heard Autotune thousands of times without ever thinking about it. Modern pop vocals, country radio, hip-hop — almost everything is pitch-corrected. But the name hides a surprisingly concrete algorithm: PSOLA, short for Pitch-Synchronous Overlap-Add.

Invented by Eric Moulines and Francis Charpentier in 1990, PSOLA is not a synthesizer. It does not generate a new signal from scratch. Instead it surgically relocates tiny fragments of the original voice — called grains — to new positions in time, so that the period between successive pitch peaks matches the target frequency. The waveform is real; only its spacing changes.

The result is pitch correction that feels transparent because it is the singer's voice, grain by grain, rearranged on a timeline. Understanding PSOLA means understanding how digital audio is just an array of numbers — and how moving numbers around in a principled way can change what your ear perceives as pitch without touching timbre.

Snap a Note to a Scale

The demo below simulates the core of PSOLA: a wobbly pitch curve (the input voice) and a target scale. Each vertical bar is one pitch grain. Press Snap to Scale to relocate every grain so its pitch lands on the nearest in-tune note — exactly what Autotune does in real time.

<!-- PSOLA pitch-correction demo -->
<p class="hint">Each red bar is one pitch grain from the input voice. The dashed lines are scale pitches. Press <b>Snap to Scale</b> to relocate every grain to the nearest in-tune note — that is PSOLA.</p>
<div class="controls">
  <label>Scale:
    <select id="scale-select">
      <option value="major">C major</option>
      <option value="minor">A minor</option>
      <option value="pentatonic">C pentatonic</option>
    </select>
  </label>
  <label>Correction speed:
    <input id="speed-range" type="range" min="1" max="10" value="5">
  </label>
</div>
<canvas id="pitch-canvas" width="560" height="200"></canvas>
<div class="status" id="status">Press Snap to Scale to correct pitch.</div>
<div class="btns">
  <button id="btn-snap" type="button">Snap to Scale</button>
  <button id="btn-reset" type="button" class="ghost">Reset</button>
</div>

/* Layout and colors for the PSOLA demo */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
.controls { display: flex; gap: 1.2rem; flex-wrap: wrap; margin-bottom: .6rem; align-items: center; }
label { font-size: .85rem; color: #555; display: flex; align-items: center; gap: .4rem; }
select, input[type=range] { font-size: .85rem; }
canvas { display: block; width: 100%; max-width: 560px; border: 1px solid #cdd9e3;
         border-radius: 8px; background: #f5f8fa; }
.status { font-size: 1rem; font-weight: 600; margin: .5rem 0; min-height: 1.4em; color: #1d3557; }
.status.done { color: #0a7d33; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// PSOLA core: detect pitch marks, relocate grains to match target pitch,
// overlap-add with a smooth window. Here we simulate the grain-relocation
// step visually — each bar is one grain plotted at its MIDI pitch.

const canvas = document.getElementById('pitch-canvas');
const ctx = canvas.getContext('2d');
const statusEl = document.getElementById('status');
const scaleSelect = document.getElementById('scale-select');
const speedRange = document.getElementById('speed-range');

// Frequency helpers: MIDI note 69 = A4 = 440 Hz
const A4 = 440;
function midiToHz(m) { return A4 * Math.pow(2, (m - 69) / 12); }
function hzToMidi(f) { return 69 + 12 * Math.log2(f / A4); }

// Scale definitions as semitone intervals within an octave (root = 0)
const SCALES = {
  major:      [0, 2, 4, 5, 7, 9, 11],
  minor:      [0, 2, 3, 5, 7, 8, 10],
  pentatonic: [0, 2, 4, 7, 9]
};

const NUM_GRAINS = 24;
const MIN_MIDI = 57; // A3 to A5, a comfortable vocal range
const MAX_MIDI = 81;

// State — input pitches, snapped output pitches, snapped flag
let inputPitches = [];
let outputPitches = [];
let snapped = false;

function randomPitches() {
  // Generate a smoothly wandering pitch curve within the vocal range
  const pitches = [];
  let cur = 65 + (Math.random() - 0.5) * 4;
  for (let i = 0; i < NUM_GRAINS; i++) {
    cur += (Math.random() - 0.5) * 3;
    cur = Math.max(MIN_MIDI, Math.min(MAX_MIDI, cur));
    pitches.push(cur);
  }
  return pitches;
}

function nearestScalePitch(midi, scaleName) {
  // Find the nearest scale note to the given MIDI pitch
  const semitones = SCALES[scaleName];
  const octave = Math.floor(midi / 12);
  let best = Infinity, bestMidi = midi;
  for (let o = octave - 1; o <= octave + 1; o++) {
    for (const s of semitones) {
      const candidate = o * 12 + s;
      const dist = Math.abs(candidate - midi);
      if (dist < best) { best = dist; bestMidi = candidate; }
    }
  }
  return bestMidi;
}

function midiToY(midi) {
  return canvas.height - ((midi - MIN_MIDI) / (MAX_MIDI - MIN_MIDI)) * (canvas.height - 20) - 10;
}

function drawScaleLines(scaleName) {
  // Draw horizontal dashed lines at each scale pitch
  ctx.save();
  ctx.strokeStyle = '#b8d0e8';
  ctx.lineWidth = 0.8;
  ctx.setLineDash([4, 4]);
  const semitones = SCALES[scaleName];
  for (let midi = MIN_MIDI; midi <= MAX_MIDI; midi++) {
    const rel = midi % 12;
    if (semitones.includes(rel)) {
      const y = midiToY(midi);
      ctx.beginPath();
      ctx.moveTo(0, y);
      ctx.lineTo(canvas.width, y);
      ctx.stroke();
    }
  }
  ctx.setLineDash([]);
  ctx.restore();
}

function drawGrains(pitches, color, alpha) {
  // Draw vertical grain bars at their respective pitches
  const gw = (canvas.width - 20) / NUM_GRAINS;
  ctx.save();
  ctx.globalAlpha = alpha;
  ctx.fillStyle = color;
  for (let i = 0; i < pitches.length; i++) {
    const x = 10 + i * gw + gw * 0.15;
    const y = midiToY(pitches[i]);
    const h = Math.max(3, gw * 0.7);
    ctx.fillRect(x, y - 2, h, 4);
  }
  ctx.restore();
}

function drawCurve(pitches, color, alpha) {
  // Draw a smooth curve connecting grain pitch positions
  const gw = (canvas.width - 20) / NUM_GRAINS;
  ctx.save();
  ctx.globalAlpha = alpha;
  ctx.strokeStyle = color;
  ctx.lineWidth = 1.5;
  ctx.beginPath();
  for (let i = 0; i < pitches.length; i++) {
    const x = 10 + i * gw + gw * 0.5;
    const y = midiToY(pitches[i]);
    if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
  }
  ctx.stroke();
  ctx.restore();
}

function render() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  drawScaleLines(scaleSelect.value);
  // Draw the original (input) pitch curve in red
  drawCurve(inputPitches, '#c92f3c', 0.55);
  drawGrains(inputPitches, '#c92f3c', 0.7);
  if (snapped && outputPitches.length) {
    // Draw the snapped (output) pitch curve in green
    drawCurve(outputPitches, '#0a7d33', 0.8);
    drawGrains(outputPitches, '#0a7d33', 0.9);
  }
}

function doSnap() {
  // Snap each grain to the nearest scale pitch, blended by speed
  const speed = parseInt(speedRange.value, 10);
  const scaleName = scaleSelect.value;
  outputPitches = inputPitches.map(p => {
    const target = nearestScalePitch(p, scaleName);
    // Speed 10 = full snap (robotic), speed 1 = gentle nudge (transparent)
    const t = speed / 10;
    return p + (target - p) * t;
  });
  snapped = true;
  render();
  const maxErr = Math.max(...inputPitches.map((p, i) => Math.abs(p - outputPitches[i])));
  statusEl.textContent = i18nFmt('Snapped %n% grains — max shift %err% semitones.', { n: NUM_GRAINS, err: maxErr.toFixed(1) });
  statusEl.className = 'status done';
}

function reset() {
  inputPitches = randomPitches();
  outputPitches = [];
  snapped = false;
  statusEl.textContent = 'Press Snap to Scale to correct pitch.';
  statusEl.className = 'status';
  render();
}

document.getElementById('btn-snap').addEventListener('click', doSnap);
document.getElementById('btn-reset').addEventListener('click', reset);
scaleSelect.addEventListener('change', () => { if (snapped) doSnap(); else render(); });
speedRange.addEventListener('input', () => { if (snapped) doSnap(); });

reset();
Result
Console

Notice that snapping does not flatten everything to one note. The algorithm finds the nearest scale pitch for each grain independently, so melodic contour is preserved while tuning errors vanish. Speed the correction up to feel the "robotic" Autotune sound; slow it down for the transparent correction pop producers prefer.

The Real Complexity

PSOLA itself is a solved algorithm: given the pitch marks and a target pitch, resynthesis is O(N)O(N) in the number of grains — it runs in linear time, fast enough for real-time use on a laptop.

The hard part is the step that comes before: pitch detection.

  • Autocorrelation finds the period TT such that the signal looks most like a shifted copy of itself. It costs O(N2)O(N^{2}) naively, but FFT-based methods bring it to O(Nlog⁡N)O(N \log N).
  • The YIN algorithm (de Cheveigné & Kawahara, 2002) improves accuracy by computing a difference function d(τ)=∑j(xj−xj+τ)2d(\tau) = \sum_{j}(x_{j} - x_{j+\tau})^{2} and scanning for its first dip below a threshold, achieving O(N)O(N) per frame.
  • In the general case, deciding the correct pitch from a noisy polyphonic recording is equivalent to solving a combinatorial search over harmonic overtones — and can be NP-hard.

So the PSOLA pipeline splits neatly: detection is the hard estimation problem, resynthesis is the easy linear pass. The algorithm's tractability is a consequence of that separation.

Where It Matters

Pitch-synchronous grain relocation is one of the most-used DSP ideas in audio:

  • Music production: Antares Auto-Tune (1997) popularized PSOLA for studio vocals; Melodyne extended it to polyphonic audio.
  • Text-to-speech: concatenative TTS systems select speech units from a database and pitch-shift them with PSOLA so that prosody sounds natural across unit boundaries.
  • Voice conversion: changing one speaker's voice to sound like another's is partly a pitch-shifting task — PSOLA resamples grains to match the target's F0F_0 contour.
  • Speech therapy: assistive tools use real-time pitch feedback to help patients with [Parkinson's disease or dysarthria maintain target pitch ranges.
  • Time-stretching: by over- or under-sampling grains in time without changing pitch, PSOLA enables speed adjustment without the chipmunk effect.

Like pattern matching, the algorithm's power comes from a simple structural insight applied at scale — and like most audio DSP, its real complexity hides in the preprocessing, not the synthesis.

Conclusion

Autotune's secret is almost anticlimactic: the algorithm just moves pieces of audio around in time, carefully enough that the ear hears a different pitch but the same voice.

PSOLA achieves this in three steps — detect pitch marks in the input, decide where each grain should land in the output, overlap-add the grains with a smooth window. The math is linear, the speed is real-time, and the result is everywhere.

The deeper lesson is about digital audio itself: a recording is nothing but an array of pressure samples. Change the rhythm of those samples and you change the pitch. The ear, it turns out, cares far more about periodicity than about the exact waveform shape — which is why a grain relocated a few milliseconds still sounds like the same singer. And that insight, as simple as it sounds, is the engine behind most modern vocal production.

Share this article

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

Comments

Loading comments...

https://www.kipuhub.com/en/article/autotune-psola/Content licensed under CC BY-NC 4.0.