Acoustic Echo Cancellation

A robot that talks hears its own voice come back from the room. A small adaptive filter learns that path and subtracts it, cutting the echo by about 35 dB.

Learn how a speaker, a microphone and a room make an echo, how an adaptive filter removes it, and what breaks when you talk over the robot.

Switch the canceller on and off. Then raise the room echo and watch the person’s voice drown or survive. After that we build every part, one piece at a time: the echo path, the filter, the step size, the cost, double-talk, the suppressor, speaker distortion, delay, and barge-in.

You need a sense of what a signal is (a number per tick of a clock) and a little Python for the code. We build the rest from zero.

Built from primary sources: Valin’s double-talk paper, the LMS reference, echo cancellation overview, the WebRTC AEC3 source and the loudspeaker-distortion literature. All links are in the Field Guide. Every toy number on this page is labelled illustrative.

Cancel the robot’s echo

0.40

Illustrative toy: 8,000 samples per second, a 64-tap echo path, speech-like noise for both voices, and a small amount of mic hiss. The canceller is the NLMS filter from Chapter 3 with the soft step from Chapter 5, and the dB figures come from running it here.

Chapter 0

The Robot That Hears Itself

See how a robot’s own voice reaches its own ear, and why that breaks every conversation it tries to have

A small robot sits on a desk. It says, “Sure, I can look that up. First I will check the weather for Tuesday, and then I will…” You want it to stop, so you say, “Wait, never mind.” The robot keeps talking. Its listening part never heard you.

The reason is simple. The robot’s microphone sits a hand’s width from its loudspeaker. Your voice is a faint sound from a metre away. The robot’s own voice is a loud sound from fifteen centimetres away. The microphone hears mostly the robot.

That returning sound is an echo: the robot’s own voice, played by the loudspeaker (the part that turns numbers into air pressure), bounced around the room, and picked up by the microphone (the part that turns air pressure back into numbers). We name the two sides of a call. The far-end signal is what the robot plays. The near-end signal is the real sound in the room, such as you talking. The microphone records the near-end sound plus the echo of the far-end.

Why a person does not notice the problem

On a phone call you hear nothing of yourself. Your phone has an acoustic echo canceller (AEC): software that predicts the echo and subtracts it from the microphone signal. Remove it and the other person hears their own voice a moment later, on every word. Calls become unusable within seconds.

A talking robot is worse than a phone. There are two listeners, the human and the software. The software is a speech recogniser, a voice-activity detector (a gate that decides whether anyone is speaking) and often a language model that listens while it talks. All three must hear only you.

How loud is loud?

Engineers measure loudness ratios in decibels (dB). A decibel is a ratio on a log scale. Plus 10 dB means ten times the power. Plus 20 dB means a hundred times. Plus 3 dB means about double. We use dB all through this lesson, because echo sizes span many orders of magnitude.

Sound from a small source falls with distance. Double the distance and the pressure halves, which is 6 dB lower. So a loudspeaker at 15 cm sounds louder to a microphone than a voice at 100 cm by 20 log10(100 / 15), about 16.5 dB, if both sources are equally loud. A robot loudspeaker is usually driven louder than a person talks, so the real gap is larger.

Move the microphone

The robot sits at the left with its loudspeaker (warm). The microphone slides along the desk. Your voice (teal) comes from 100 cm away. Drag the slider and read the delay and the level of the echo against you.

15 cm

Direct path only, in free air. Delay is distance divided by the speed of sound, 343 m/s. Level uses the inverse-distance law for two equally loud sources: 20 log10(100 / d). A real speaker is louder than a voice, and the room adds reflections (Chapter 1), so real echoes are stronger than this bar.

Look at the read-out as you drag. Even at 60 cm the echo arrives under 2 ms after the loudspeaker moves, and it is still louder than you. A tiny robot cannot move its microphone far enough away. The echo must be removed in software.

Two ideas to hold on to

First, the robot knows its own voice exactly. It wrote the numbers it sends to the loudspeaker. That known signal is the reference. A canceller does not guess what the echo sounds like. It learns how the room changes the reference.

Second, the room changes the sound in a way that does not change for a while. A wall stays where it is. So the change can be described by a short list of numbers, and a filter can learn that list. Chapters 1 to 3 build exactly that.

The harder chapters follow. What if you talk while the filter is still learning (Chapter 5)? What if the loudspeaker distorts (Chapter 7)? What if the software delays the reference (Chapter 8)? And what do all these fixes buy a robot that must stop when you interrupt (Chapter 9)?

The road

  1. The echo path: loudspeaker to room to microphone, as a list of numbers.
  2. Subtracting the echo: the adaptive filter and the number that scores it.
  3. LMS and NLMS: how the filter learns, and why the step size matters.
  4. Long rooms, cheap filters: frequency-domain and block filters.
  5. Double-talk: you and the robot speak together.
  6. Residual echo suppression: a gain that cleans up what the filter missed.
  7. Nonlinear distortion: a loudspeaker that bends the signal.
  8. Delay and drift: finding where the echo starts.
  9. Barge-in and full duplex: why all this lets you interrupt a robot.
  10. The Field Guide: numbers, checklist, code and sources.
Why can a robot remove its own echo but not, say, a stranger’s voice in the room?

Chapter 1

The Echo Path

Describe everything a room does to a sound with one short list of numbers

Stand in an empty hallway and clap once. You hear the clap, then a quick scatter of repeats, then a long soft fade. That whole pattern is the hallway’s answer to one sharp click. Clap in a carpeted bedroom and the answer is short and dull. The room is the same each time you clap. Only the click changes.

A robot’s echo works the same way. The robot plays a sound. The sound travels through the loudspeaker, across the room, off the walls and into the microphone. We call that whole journey the echo path. We want to describe it with numbers, so a computer can undo it.

One click is enough

Here is the useful trick. A digital sound is a stream of samples: one number for each tick of a clock. At 16,000 ticks a second, the clock ticks every 62.5 microseconds. Any sound is a row of clicks of different heights, one per tick.

So we only need to know the room’s answer to one click of height 1. That answer is the impulse response. We write it as a list h[0], h[1], h[2], and so on. Each number is a tap. Tap k says how much of a click comes back k ticks later.

Now take a real sound x. Its sample at tick n is x[n]. That sample is a click of height x[n]. The room answers with a copy of h, scaled by x[n] and starting at tick n. The microphone hears all the answers added together. That rule is called convolution.

y[n]
The echo at tick n: what the microphone hears of the robot’s voice.
∑k=0L−1
Add up L terms, one for each tap, from the first tap (k = 0) to the last (k = L − 1).
h[k]
Tap k of the impulse response: how much of a click returns k ticks later.
x[n − k]
The robot’s sample from k ticks ago, the one whose reflection arrives right now.

Work one by hand

Take a tiny room with three taps, h = [0.5, 0.3, −0.1]. The robot plays x = [1, 2, 0, −1]. We find y at each tick. Taps that reach before the start of x count as zero.

y[0] = 0.5·1 = 0.5   y[1] = 0.5·2 + 0.3·1 = 1.3   y[2] = 0.5·0 + 0.3·2 − 0.1·1 = 0.5

y[3] = 0.5·(−1) + 0.3·0 − 0.1·2 = −0.7   y[4] = 0.3·(−1) − 0.1·0 = −0.3   y[5] = −0.1·(−1) = 0.1

The robot sent four samples. The room returned six. The echo is longer than the sound that caused it, by exactly L − 1 = 2 ticks. That is the tail. In a real room the tail runs for hundreds of milliseconds.

What a real path looks like

Look at the stems in the device below. The first big tap is the direct path: sound that goes straight from loudspeaker to microphone. In a small robot it arrives within a millisecond. After it come a few early reflections off the desk and nearest wall. Then comes the reverberation tail, thousands of tiny reflections that blur together and fade.

Engineers measure the fade with RT60: the time the echo takes to fall by 60 dB. A living room is often near 0.4 s. A hall can pass 1 s. At 16,000 samples per second, 0.4 s needs 6,400 taps. That number decides how big the canceller must be, and Chapter 4 returns to it.

Read the echo path of three rooms

Each stem is one tap of the impulse response, in time order. Pick a room. Then press Send a click and watch the answer arrive tap by tap.

Illustrative rooms: RT60 of 0.06 s, 0.4 s and 1.2 s, and echo return loss of 6, 12 and 18 dB. Tap heights are random with an exponential fade, a common textbook model of a reverberant tail. Tap counts assume 16,000 samples per second.

How loud is the echo?

The path also sets the echo’s loudness. The echo return loss (ERL) is the drop in level from the loudspeaker to the microphone, in dB. An ERL of 12 dB means the echo has one sixteenth of the power of the signal that made it. A small robot has a low ERL, because the microphone is close. ITU-T G.168, the telephone standard for echo cancellers, expects an ERL of at least 6 dB.

One more fact matters later. The path is linear: double the input and the echo doubles, and two inputs add. It is also slowly changing: it stays put until something moves. A person who steps closer, a door that opens, or a robot that turns its head changes the taps. The canceller must keep learning.

The data flow

In code the pieces are plain arrays. The reference x is a block of 160 float samples per 10 ms frame at 16 kHz. The echo path h is an array of L floats. The echo is a convolution, one multiply-add per tap per sample. The microphone frame is d = echo + near-end voice + noise, also 160 floats. The canceller sees x and d and never sees h. Its job is to recover h from those two.

Failure, then measurement, then fix. The symptom: the robot’s speech recogniser writes down the robot’s own sentence. The measurement: play white noise, record the microphone with nobody speaking, and compare powers. That gives the ERL, and the delay of the first tap. The fix is not louder speech or a better microphone. It is to learn h and subtract. That starts in Chapter 2.

A room has an RT60 of 0.4 s. At 16,000 samples per second, about how many taps does a filter need to cover the echo tail?

Chapter 2

Subtracting the Echo

Predict the echo from what the robot played, take it away, and score how much is left

You are at a party. Your favourite song plays loudly, and a friend whispers a secret. You still catch the words. You know the song well, so your brain quietly sets it aside. The whisper is what remains.

An echo canceller does the same with numbers. The robot knows the song: its own voice, as sent to the loudspeaker. If the canceller can predict how that voice sounds after the room, it can take the prediction out of the microphone signal. What remains is the person.

The loop in four steps

The tool is a filter: a recipe that makes each output sample from a few recent input samples. Ours uses the same form as the room. Its recipe is a list of taps w[0] to w[L−1], our guess at the room’s h. We call it an adaptive filter because the taps change over time. For every tick the canceller does four things.

  1. Predict. Run the reference through the guess: ŷ[n] = ∑ w[k] · x[n−k]. This is the echo we expect.
  2. Subtract. Take the prediction from the microphone: e[n] = d[n] − ŷ[n]. This is the error, and it is also the output sent to the recogniser.
  3. Judge. If the guess is perfect and nobody speaks, e is zero. Any echo left in e means the guess is off.
  4. Correct. Nudge each tap so that next time e is smaller. Chapter 3 gives the exact nudge.

Why can the canceller learn from e at all? Because e carries the room’s mistake. If w is wrong, some of the robot’s voice is left in e. That leftover is correlated with the reference, meaning it rises and falls with it. The correction looks for exactly that pattern and removes it. Anything in e that does not follow the reference, such as your voice, gives it nothing to learn from.

Scoring: ERLE

We need one number for “how much echo is gone”. It is the echo return loss enhancement (ERLE): the extra loss the canceller adds, in dB.

ERLE
How many dB the echo has fallen. Bigger is better. Most telephone-style cancellers reach 18 to 35 dB.
Pecho
The average power of the echo before the canceller: the mean of y[n] squared.
Presidual
The average power of the echo that is still in e[n]: the mean of (y[n] − ŷ[n]) squared. The person’s voice is not counted.

Work one. Say the echo has power 0.64 and the leftover echo has power 0.0064. The ratio is 0.64 / 0.0064 = 100. Then 10 log10(100) = 20 dB. The leftover is a hundredth of the echo in power, and a tenth in amplitude. Together with the room’s own ERL of 12 dB, the total echo loss is 32 dB.

Our toy tests below can measure Presidual exactly, because we know both the true echo and the filter’s guess. A real product cannot, since the true echo is hidden under the person’s voice. It estimates ERLE from the signals it has.

Watch the filter learn the room

Top: the room’s true taps (purple) and the filter’s guess (blue). Bottom: ERLE over time. Drag the slider to choose how many samples the filter has heard.

125 ms

Illustrative: a 16-tap path, 8,000 samples per second, speech-like noise from the robot, an NLMS filter with step size 0.5 (Chapter 3), and a little microphone hiss. ERLE is measured in blocks of 250 samples, 31 ms each, from the true echo and the filter’s guess.

Drag to the start. The blue stems sit at zero, so nothing is predicted and the ERLE is near zero. Drag right. After about a tenth of a second the big first tap is found. After a few tenths the small tail taps match too. The hiss in the microphone sets a floor, so the curve flattens.

One detail decides everything. The reference must be the exact signal that reached the loudspeaker. If the app changes the volume after the reference was copied, the filter learns the room and that gain, and relearns whenever the gain moves. Tap the reference as late in the playback chain as you can, and keep it time-aligned with the microphone frames, 160 samples at a time.

What the output is for

The error e is not only a training signal. It is the cleaned microphone stream, and everything downstream reads it: the speech recogniser, the voice-activity detector, the language model. In a video call it is also what the far side hears. So a canceller has two jobs that pull in opposite directions. It must remove echo, and it must leave your voice alone.

Failure, then measurement, then fix. The symptom: after a minute the robot still reacts to its own speech. The measurement: log the ERLE every second. If it sits near 10 dB, the taps are not tracking the room. The causes are on the next pages: a step size that is too small or too large, a filter too short for the tail, a delay the filter cannot see, or a loudspeaker that bends the sound.

The leftover echo has one thousandth of the echo’s original power. What is the ERLE?

Chapter 3

LMS and NLMS

Derive the nudge that teaches each tap, then fix it so it works on loud and quiet speech alike

Imagine tuning an old radio with a friend who calls out “warmer” or “colder”. Two things matter. The friend tells you which way to turn the dial. You decide how far to turn it. A small turn is slow but safe. A big turn is quick, and you may overshoot.

The least mean squares filter (LMS) tunes the taps in the same way. The error e tells it which way. A number called the step size, written μ, sets how far. We now build the rule from one idea.

Derive the nudge

We want the error to be small. A good score is its square, e², because a square is never negative and big misses count more. Each tap w[k] changes the error a little. If we raise w[k] by a small amount, the prediction rises by that amount times x[n−k], so the error falls by the same.

So the slope of e² with respect to w[k] is −2 · e · x[n−k]. To go downhill we move each tap the other way. We drop the 2 into the step size. The result is the whole rule.

wk[n+1]
Tap k after this tick’s correction.
wk[n]
Tap k before the correction.
μ
The step size: how far to turn the dial on each tick.
e[n]
The error now: microphone minus the prediction. It says how wrong we are and in which direction.
x[n − k]
The reference sample that fed tap k. A tap only changes if its sample was active.

Read it aloud. “Nudge each tap by the error times the sample that tap just saw.” If a tap saw nothing, it does not move. If it saw a lot and the error is large, it moves a lot.

The loudness problem

This rule has a flaw. The size of the nudge grows with how loud x is. Shout, and every nudge becomes huge, so the taps overshoot and the filter can blow up. Whisper, and the nudge is tiny, so the filter hardly learns. Speech goes from a whisper to a shout in a second. One fixed μ cannot fit both.

The cure is to divide by how loud the last L samples were. We measure loudness as the sum of their squares, xTx. The result is normalized LMS (NLMS). Its nudge is μ · e · x / (xTx + ε). The small ε stops a divide by zero in silence.

Check it with numbers. Let x = [2, 1, −1] and w = [0.2, 0.1, 0]. The mic hears d = 1.5. The prediction is 0.2·2 + 0.1·1 + 0 = 0.5, so e = 1.0. Loudness xTx = 4 + 1 + 1 = 6. With μ = 0.5 each tap moves by 0.5 · 1.0 · x / 6, which is [0.167, 0.083, −0.083]. The new w is [0.367, 0.183, −0.083]. The new prediction is 0.733 + 0.183 + 0.083 = 1.0. The new error is 1.5 − 1.0 = 0.5.

The error fell from 1.0 to 0.5, which is exactly (1 − μ) times the old error. That holds for any x. So μ = 1 removes the error on this sample in one step, and μ = 0.5 halves it. Any μ between 0 and 2 shrinks the error. Above 2 it grows, and the filter diverges.

pythondef nlms_step(w, x_buf, d, mu=0.5, eps=1e-6):
    y_hat = w @ x_buf              # predict the echo, shape () from (L,) and (L,)
    e = d - y_hat                  # the error, also the cleaned output
    w += mu * e * x_buf / (x_buf @ x_buf + eps)
    return e

Fast or clean? The step-size trade

Every real microphone has hiss, and other sounds always leak in. The filter treats that noise as error and chases it. A large μ chases hard, so the taps jitter around the true values. A small μ ignores the noise but learns slowly. For white input, a textbook result says the extra error from this jitter is about μ / (2 − μ) times the noise power. At μ = 1 that factor is 1. At μ = 0.1 it is 0.053, about 19 times smaller.

The same textbook analysis gives the speed. With white input the error power shrinks by a factor of about 1 − μ(2 − μ) / L on each tick. For L = 64 and μ = 1 the error power falls to about 37 percent in 64 ticks, which is 8 ms at 8 kHz. Real speech is not white, so real filters are slower than this. The device below shows the true speed on speech-like input.

Turn the step size

The green curve is ERLE over time for the step size you choose. Press Move the robot to change the room at 0.375 s, and watch the filter re-learn.

0.50

Illustrative: 64-tap path, 8,000 samples per second, speech-like input, moderate mic hiss, no talker. The room swap changes every tap at 0.375 s. Times are read off the ERLE curve in 31 ms blocks. The μ/(2−μ) rule is the textbook white-noise result; speech is not white, so use it for the trend only.

Try μ = 0.5 and then μ = 1.0. Both reach about 20 dB within 150 ms, and the 1.0 curve is more ragged. Try μ = 0.1. It is far too slow: in 750 ms it has not caught up, although it would end cleaner with more time. Try μ = 1.9. It is stable on paper and nearly useless, because each step overshoots. Then move the robot. A small μ takes a long time to follow the new room. The best μ is not a constant. Chapter 5 makes it change with time.

Failure, then measurement, then fix. The symptom: the echo gets worse for a second whenever someone moves the robot. The measurement: ERLE drops to near 0 dB, then climbs back over several hundred milliseconds. The fix is a larger step right after a change, and a smaller one once the filter has settled.

An NLMS filter has error e = 1.0 on a tick and uses μ = 0.25. What is the error on the same sample after the update?

Chapter 4

Long Rooms, Cheap Filters

Count what a long filter costs, then move the work into the frequency domain to make it affordable

A living room needs about 6,400 taps (Chapter 1). Run the NLMS rule from Chapter 3 on every sample. Each tick costs one multiply-add per tap to predict the echo, and one more per tap to update the taps. That is about 2 × 6,400 = 12,800 multiply-adds per sample. At 16,000 samples per second, the filter needs 205 million multiply-adds every second.

A small robot also runs a speech model, a camera and a motor controller on the same chip. Spending that much on echo alone is hard. We need the same answer for far less work.

Tones instead of clicks

Chapter 1 split a sound into clicks. There is a second way to split it, into pure tones of different pitch. Think of a chord on a piano: one sound, made of several notes. The Fourier transform lists how much of each note a sound holds. Its fast version is the FFT (fast Fourier transform). An FFT of N samples costs roughly N log2 N multiply-adds.

Here is why this helps. A room treats each tone on its own. It makes one tone louder or softer and delays it a little, but it never turns one tone into another. So filtering a sound through the room, which costs L multiplies per sample in clicks, costs one complex multiply per tone in tones. The rule has a name: convolution in time is multiplication in frequency.

The block recipe

The frequency-domain filter works on blocks: a group of B samples handled together. The steps for each block are these.

  1. Transform. Take the last 2B reference samples and run the FFT. This gives X, one number per tone, shape [B+1] complex.
  2. Predict. Multiply X by the filter W, one product per tone. Run the inverse FFT, and keep the last B outputs. The first B are wrong because the transform wraps around. This trick is called overlap-save.
  3. Subtract. Take the prediction from the B microphone samples to get the block of errors.
  4. Update. Transform the error, and nudge each tone of W by that tone’s error times that tone’s reference, divided by that tone’s own power.

Step 4 hides a second gain. In the time domain, speech makes the filter slow, because neighbouring samples are alike and the nudges overlap. In the frequency domain each tone has its own normalizer, so every tone converges at about the same speed. The filter learns the weak high tones as fast as the strong low ones.

The bill

Count the cost per block of L samples when the block size equals the filter length. The recipe needs about five FFTs of size 2L and some per-tone products. That is roughly 10 log2(2L) + 8 multiply-adds per sample, against 2L in the time domain. For L = 2,560 taps the time-domain cost is 5,120 per sample. The frequency-domain cost is about 10 × 12.3 + 8 = 131. That is forty times less.

One problem remains. A block of 2,560 samples is 160 ms of waiting before the first output. A robot cannot wait that long. The fix is to cut the long filter into short partitions, each B samples long, for instance 4 ms. All partitions share the same recent FFTs of the reference. Each gives its own product, and the products add up. Delay is now one short block, and the filter is still long. This design is called a partitioned block frequency-domain filter, or a multidelay filter. The WebRTC AEC3 canceller and the Speex canceller both use it.

How long is long enough?

A filter that is too short leaves the end of the tail unmodelled. That part of the echo goes straight through. We can compute the damage. A tail whose power falls 60 dB over RT60 loses power as 10−6t/RT60. If the filter covers the first Tc seconds, the echo it misses has 10−6Tc/RT60 of the total power. That gives a hard ceiling.

ERLEmax
The best ERLE any amount of learning can reach with this filter length.
Tc
The time the filter covers: its number of taps divided by the sample rate.
RT60
The time the room echo takes to fall by 60 dB.

Work one. RT60 is 400 ms and the filter covers 160 ms. The ceiling is 60 × 160 / 400 = 24 dB. To reach 36 dB the filter must cover 240 ms, or 3,840 taps at 16 kHz.

Size the filter for the room

The curve is the room’s echo fading in dB. The shaded part is what your filter covers. Everything to the right of it leaks through.

400 ms
160 ms

Idealised exponential tail, ignoring the direct path. 16,000 samples per second. Cost counts multiply-adds per second: time domain 2L per sample; frequency domain 10 log2(2L) + 8 per sample, a rough textbook-style model, not a benchmark of any product.

Set the room to 400 ms and the filter to 160 ms. The ceiling reads 24 dB. Raise the filter to 240 ms and the ceiling reaches 36 dB. Watch the cost bars: the time-domain bar explodes while the frequency-domain bar barely moves. That gap is why every modern canceller lives in the frequency domain.

Failure, then measurement, then fix. The symptom: in a large room the robot echoes itself, though the same code works on the desk. The measurement: ERLE plateaus near 15 dB however long you wait. Compare the plateau with 60 × Tc / RT60. If they match, the filter is too short. The fix is more partitions, or a suppressor for what remains (Chapter 6).

A room has an RT60 of 600 ms. The filter covers 150 ms. What is the best ERLE any learning can reach?

Chapter 5

Double-Talk

Keep the filter learning the room, not you, when you and the robot speak at the same time

The robot is mid-sentence and you cut in: “No, the other one!” For the next second two voices reach the microphone. One is its own echo. The other is you. This overlap is called double-talk, and it is the moment the whole system exists for.

It is also the moment the filter is most likely to break. Recall the rule from Chapter 3: nudge each tap by the error. Now the error holds your voice as well as the leftover echo. Your voice is not echo, and no setting of the taps can predict it. But the filter does not know that. It sees a big error and tries to fix it.

How the filter hurts itself

Your voice is random from the filter’s point of view. Each nudge pushes the taps a little in a random direction. Over many ticks the taps wander away from the true room. The prediction gets worse, and more echo leaks into the output. The damage is not just a pause in learning. The filter un-learns what it knew.

Valin’s 2007 paper on echo cancellation gives the size of the effect. A canceller with no protection at all fails to converge once the near-end voice is 10 dB or more above the echo. In the device below you can watch the same thing happen on a toy.

Fix one: detect and freeze

The classic cure is a double-talk detector (DTD). It watches for your voice, and when it hears it, it freezes the update. The taps stay where they were until you stop. The simplest detector is the Geigel algorithm.

Here is its logic. Say the echo path loses at least 6 dB (the ITU-T G.168 telephone standard assumes this). Then echo alone is never louder than half the loudest recent reference sample. So the detector finds the peak of the reference over the last L samples, multiplies by 0.5, and compares. If the microphone sample is bigger than that, something else is speaking.

A few better detectors exist. The coherence method (Gänsler) and the normalized cross-correlation method (Benesty) compare how much the microphone signal still follows the filter’s own prediction. Valin’s comparison set both thresholds at 0.3. They all share a weakness: the right threshold depends on the room, the loudness and the noise. A hard threshold is also late. By the time it fires, a few of your first samples have already hit the taps.

Fix two: turn the step down, softly

Valin’s paper proposes dropping the yes-or-no call. Instead, the step size follows a ratio. If the error is mostly leftover echo, learn at full speed. If the error is mostly something else, learn slowly. In symbols:

μ[n]
The step size used at tick n. It changes every tick now.
μmax
The fastest allowed step. Valin used 0.5.
Pres
An estimate of the power of the echo still left in the output.
Pe
The power of the whole error signal, which includes your voice.

Work two cases with μmax = 0.5. You are silent: the error is leftover echo, so Pres = Pe = 0.01, the ratio is 1, and μ = 0.5. You start talking: Pe jumps to 0.1 but the leftover echo is still 0.001. The ratio is 0.01 and μ = 0.005, a hundred times slower. Now the room changes instead: the leftover echo grows, the ratio rises, and the step speeds up. One rule covers both cases.

The hard part is the estimate of Pres, since a real canceller cannot see the true echo. Valin estimates it as a leakage factor times the echo power. The factor is the inverse of the ERLE, found by comparing the output power with the echo power over time. In his tests the soft step beat two classic detectors by more than 4 dB of ERLE on average, and it re-adapted faster after the echo path changed.

Talk over the robot

You speak from 0.375 s to 0.675 s (shaded). Choose how the filter is protected, and set how loud you are. Top: ERLE. Bottom: the step size the filter used.

1.0

Illustrative toy, 8,000 samples per second, 64 taps, μ = 0.6. The Geigel detector uses a threshold of 0.5 and holds the freeze for 1.5 filter lengths. The soft step here uses the true leftover echo, which a real canceller must estimate as Valin describes, so it shows the best case of the idea. ERLE counts echo only.

Start with no protection. Before you talk ERLE sits near 35 dB. While you talk it dives below zero: the canceller makes the echo worse than having none. Switch to the Geigel freeze. The damage shrinks, but the detector is late and quiet speech slips by. Switch to the soft step. ERLE stays high through the whole overlap, and the lower plot shows why: the step falls the moment you start.

Failure, then measurement, then fix. The symptom: the echo returns for a second after every interruption, and the robot sometimes answers its own words. The measurement: log ERLE and step size together. A drop in ERLE that starts when double-talk starts points at the update, not the room. The fix is a detector or a soft step, plus a larger step briefly after any sudden level change.

Why does double-talk hurt a plain NLMS filter?

Chapter 6

Residual Echo Suppression

Turn down the bands where a faint echo is left, without turning down your voice

The filter has done well. ERLE is 30 dB. In a quiet room, though, the robot’s voice is still a faint ghost in the output. A voice-activity detector set to catch a whisper hears the ghost and thinks someone spoke. A speech recogniser may write down half a word of the robot’s own sentence.

The filter cannot remove the rest. Part of the tail lies past its length (Chapter 4). Part of the echo came from distortion it cannot model (Chapter 7). Part is the filter still adjusting after a change. We call the leftover the residual echo. A second stage, the residual echo suppressor, handles it.

A mixing desk with many faders

Picture a mixing desk with one fader for each pitch range. A sound engineer who hears leftover robot in the low notes pulls the low fader down, and leaves the others alone. Do it fast enough, automatically, and the ghost disappears.

The suppressor does this on short frames of 10 to 20 ms. It splits each frame into bands (pitch ranges) with the same FFT as Chapter 4. For every band it picks a gain, a number between 0 and 1 that scales that band. A gain of 1 leaves the band alone. A gain of 0.03 turns it down by 30 dB. It then rebuilds the sound from the scaled bands.

Choosing the gain

The suppressor needs two estimates for each band: the power of the whole output, Pout, and the power of the residual echo in it, Pres. The fraction Pres / Pout says how much of the band is echo. If all of it is, the gain should be tiny. If none, 1. A common choice, in the style of a Wiener filter, is this.

G
The gain for one band in one frame, between gmin and 1.
gmin
The floor. It stops a band from being cut to exactly zero, which sounds like holes in the speech.
α
Strength. Above 1 the suppressor over-subtracts to be safe. Below 1 it is gentle.
Pres / Pout
The share of this band that is leftover echo.

Work two bands with α = 1. Band A has Pout = 0.5 and Pres = 0.2. The gain is 1 − 0.4 = 0.6, a cut of 4.4 dB. Band B holds only echo: Pout = Pres = 0.2. The gain is 1 − 1 = 0, so it falls to the floor, gmin = 0.03, a cut of 30 dB.

Where Pres comes from

This is the hard part, and where designs differ. The suppressor cannot see the residual directly, because your voice is mixed with it. It estimates it from the filter. Roughly: take the echo the filter predicted, power Pecho, and divide by the ERLE the filter has achieved. Add a term for echo that comes later in the tail. In the WebRTC AEC3 source, the estimator uses the linear filter’s output when that filter is judged usable. It sets the residual to zero when the echo is judged inaudible. It also falls back to a more cautious rule, with a very conservative gain, when the echo may be saturated or distorted.

Pull the faders down

Each pair of bars is one band, low pitch on the left. Purple is leftover echo, teal is your voice. Top: before the suppressor. Bottom: after. Raise the strength, then switch on You are talking.

1.0

Illustrative: 16 bands on a log scale from 50 Hz to 4 kHz, a fixed echo shape that is strong at low pitch, and a fixed speech shape with two bumps of voiced energy. gmin = 0.03. The residual-echo estimate is taken as exact here; a real one is noisy, which is why real suppressors are less clean.

Leave “You are talking” off and push α up. The echo bars vanish, and nothing is lost. Now switch your voice on. Bands where you are loud and the echo is weak keep their gain near 1. But bands where the two overlap get cut, and your voice goes down with the echo. The read-out puts a number on it. This is the core trade: a stronger suppressor leaves less ghost and damages more speech.

Real suppressors soften the trade with extra logic. They smooth gains over time so they do not flutter. They cut less when they think you are talking. They also use the filter’s own ERLE: when it is high, they cut less, since little is left to remove.

Failure, then measurement, then fix. The symptom: your words come out chopped at the start, or sound watery during an interruption. The measurement: compare your voice before and after the suppressor, in dB, during double-talk. Treat a loss above 3 dB on a key band as a warning. The fix is a lower α, a higher gmin during double-talk, and a better echo estimate. Do not hide a weak filter behind a heavy suppressor.

A band has Pout = 0.5 and an estimated Pres = 0.2. With α = 1 and gmin = 0.03, what is the gain?

Chapter 7

When the Speaker Bends the Sound

See why a loud, tiny loudspeaker puts a ceiling on any linear filter, and what to do about it

Turn the volume of a cheap pocket speaker all the way up. The sound gets harsh and buzzy. The small cone cannot move as far as the signal asks, so it hits its limit and the peaks go flat. Sound that has been squashed like this is distorted.

A robot is full of such speakers. Its loudspeaker is small, driven hard to be heard across a room, and fixed beside a plastic case that can rattle. Its voice leaves the speaker changed.

Why a linear filter cannot follow

Recall what the filter of Chapter 2 can do. It adds delayed, scaled copies of the reference. That is all. If the reference holds only low notes, the prediction holds only low notes. A filter of this kind is linear: double the input and the output doubles, and nothing new appears.

Distortion creates new notes. Flatten the peaks of a pure tone and you add its third, fifth and higher multiples, the harmonics. The microphone hears these harmonics. The reference does not hold them. No choice of taps can build a note from nothing, so the harmonics pass through as residual echo.

We can estimate the size. Say the speaker acts like y = tanh(g·x), a smooth squash. For small inputs, tanh(u) ≈ u − u³/3. Feed a pure tone x = A sin θ, and let u = gA = 0.5. Use sin³θ = (3 sin θ − sin 3θ) / 4. The output then holds a fundamental of about u − u³/4 = 0.469, and a third harmonic of u³/12 = 0.0104. The ratio is 20 log10(0.0104 / 0.469), about −33 dB. So the best a linear filter can do on that tone is about 33 dB of ERLE, however long it learns. Raise u and the ceiling falls fast. This is a small-signal estimate; at hard clipping it is worse.

Three ways out

  1. Model the speaker. Put a nonlinear block in front of the linear filter, and adapt both. Guérin and colleagues (2003) used a cascade of a polynomial Volterra filter, which models the loudspeaker, followed by a linear filter for the room. A second-order term covers many cases. The cost is slower learning and more compute.
  2. Straighten the speaker. A pre-processor can undo the squash before the sound leaves the amplifier, and then a linear canceller works. This needs a measured speaker curve, and the curve drifts with heat and age.
  3. Suppress what is left. Estimate the harmonic echo that distortion makes, and give that estimate to the residual suppressor of Chapter 6. A published patent (EP2671223B1) describes this. It is cheap, and it costs some near-end speech.

There is a fourth, boring option that often wins: do not drive the speaker so hard. A limiter in the output path keeps peaks below the clipping point. Also tap the reference after that limiter, so the filter sees what the speaker really played.

Where the reference is tapped decides how much distortion the filter can even see. The data path has stages: the app’s samples, then volume and equaliser, then a limiter, then the converter, the amplifier and the speaker. A tap at the app sees the cleanest signal and misses every later change. A tap after the limiter sees the limiter’s work. The best tap is a hardware loopback that reads what the converter really sent. It costs a pin or a channel, and it also carries the true timing, which Chapter 8 needs.

Push the speaker too hard

Left: the speaker’s squash curve at the loudness you choose. Right: the ERLE each filter reaches after learning, for every loudness. Drag the slider, then switch on the speaker model.

1.00

Illustrative toy: the speaker is y = tanh(k·x)/k, so k = 0 is perfectly linear. The robot’s speech-like voice peaks near 3.9. The speaker-model filter assumes the same curve has already been measured and is applied to the reference; a real one must learn it and track its drift. ERLE is the steady value after 750 ms, 64 taps.

Slide the loudness from 0 up. At 0 both filters reach about 35 dB. With a linear filter the ERLE falls steeply: from 35 dB to 22 dB already at a loudness of 0.5, which is only mild squashing on the curve at left. With the speaker model it falls only a few dB. The gap between the two lines is the part of the echo that no linear filter could ever predict.

Failure, then measurement, then fix. The symptom: the canceller works at low volume and fails when the robot speaks loudly. The measurement: sweep the playback level, and plot ERLE against it. A drop that starts at a certain level, while the room and filter are unchanged, is distortion. Look at the microphone spectrum while playing a single tone: extra peaks at the tone’s multiples confirm it. The fix, in order of cost: cap the playback level, tap the reference after the limiter, add a nonlinear model, then a suppressor.

Why can a linear adaptive filter never cancel the third harmonic made by a clipping speaker?

Chapter 8

Delay and Drift

Find out when the echo starts, so the filter looks at the right part of the reference

Ask a friend to clap, and press record on your phone at the same moment. The clap shows on the recording a fraction of a second late. Something between the press and the sound took time. A robot has the same lag between the moment its software hands a sound to the speaker and the moment that sound reaches the microphone.

We call this the bulk delay. Chapter 1 showed the air part, under 2 ms across a desk. The software and hardware part is much bigger. Audio goes through operating-system buffers, a driver, maybe a USB or Bluetooth link, the converter, the amplifier, and then back through the microphone’s own buffers. The total is often tens of milliseconds, and over Bluetooth it can pass 200 ms.

A filter that looks at the wrong time

The filter of Chapter 2 holds L taps. Tap k looks at the reference k ticks ago. So the filter sees only the last L samples of the reference. If the echo arrives D ticks late and D is larger than L, the echo comes from a part of the reference the filter never sees. It cannot learn anything. ERLE stays near 0 dB, however well you tune the step size.

Making the filter longer is wasteful. Most of its taps would be zeros that cover the dead time, and each tap costs compute (Chapter 4). A smarter plan: estimate the delay D, then hold the reference back by about D ticks, so the filter’s window opens just where the echo starts.

Finding the delay: line up the two signals

The echo is a delayed copy of the reference. So slide the reference along the microphone signal, and at each slide amount, measure how well they match. The slide where they match best is the delay. The match score is the cross-correlation: multiply the two signals sample by sample at each slide τ and add up.

r[τ]
How well the reference, slid back by τ ticks, matches the microphone signal.
∑n
Add the product over many ticks, so noise averages out.
x[n − τ]
The reference from τ ticks ago.
d[n]
The microphone sample now.
D̂
The estimated delay: the slide with the highest score.

Work it with six samples. The reference is x = [1, −1, 2, 0, 0, 0]. The echo comes 2 ticks late at half size, so d = [0, 0, 0.5, −0.5, 1, 0]. At τ = 0 the score is 1.0. At τ = 1 it is −1.5. At τ = 2 it is 1·0.5 + (−1)(−0.5) + 2·1 = 3.0. At τ = 3 it is −1.5. The peak sits at τ = 2, so D̂ = 2.

In practice the sums run over seconds of audio and are computed with the FFT of Chapter 4. Speech is coloured: it has more low pitch than high, which smears the peak. A common sharpening is to whiten both signals first, so every pitch counts equally. That is the idea behind the phase transform (PHAT) used in many delay estimators.

Find the delay

The filter window is 64 ms (shaded). Top: the correlation score at each slide. Bottom: ERLE over time. Move the delay past the window, then switch on the shifted reference.

140 ms

Illustrative toy: 8,000 samples per second, so 140 ms is 1,120 samples. The filter has 64 taps (8 ms) at its window start, the room tail is short, and the estimate comes from brute-force correlation over 5,000 samples. The reference is held back to 3 ms before the peak, a safety margin, because speech smears the peak. Real products use FFT correlation over longer spans and keep re-estimating.

Set the delay to 0 and the filter works: ERLE climbs past 30 dB. Slide to 140 ms. The window sees only the wrong part of the reference, and the curve stays at 0. The correlation peak still stands out clearly at 140 ms. Now switch on the shifted reference. The filter looks at the right moment, and ERLE returns.

The delay moves

Delay is not fixed for life. The speaker and the microphone often run on two different clocks. Both claim 16,000 ticks a second, but one is a little faster. A mismatch of 100 parts per million is common. At 16 kHz that is 1.6 samples a second. After one minute the echo has slid by about 96 samples, which is 6 ms. A 6 ms slip can walk the direct tap out of a short filter’s window.

Operating systems also drop or repeat a buffer now and then, and the delay jumps by a whole buffer. So a robust canceller keeps measuring. The WebRTC AEC3 code keeps both an external delay estimate and a delay found from the filter itself, and watches for changes. A product should also resample, or at least re-align, when the slip grows.

Failure, then measurement, then fix. The symptom: the canceller works on the bench with a wired speaker, then fails over Bluetooth or after the robot has run for an hour. The measurement: log the correlation peak position once a second, together with ERLE. A moved peak with a falling ERLE says the delay shifted. The fix: re-estimate often, keep a margin of taps before the peak, and tap the reference at a point whose timing you know.

The speaker and microphone clocks differ by 100 ppm at 16,000 samples per second. About how far does the echo slide in 10 seconds?

Chapter 9

Barge-In and Full Duplex

See how clean microphone audio lets you interrupt a robot, and what breaks when it is not clean

Two people talking over a table do not take strict turns. One says “mm-hm” while the other speaks. One cuts in with “wait, which one?” and the other stops mid-word. The talk flows in both directions at once. Engineers call this full duplex: sending and receiving at the same time.

A walkie-talkie is half duplex. Only one side talks, and the other waits. The simplest robot works this way. While it speaks, it shuts its ears so it cannot hear itself. That fix is cheap, and it makes interruption impossible. You must wait for the robot to finish every sentence.

What barge-in needs

To barge in is to speak over the robot and have it stop. Three things must happen, in order. The robot’s ears must work while it speaks. Software must decide that the sound in the microphone is a person and not itself. Then the robot must cut its speech quickly.

The middle step is the fragile one. Here is the signal path, with the shapes of the data at each stage.

  1. Microphone frame. 160 samples every 10 ms at 16 kHz, holding you plus the echo.
  2. Echo canceller. It also takes the reference frame, the 160 samples that were just played. It subtracts the predicted echo (Chapters 2 to 5).
  3. Residual suppressor. It turns down the bands with echo left (Chapter 6).
  4. Voice-activity detector (VAD). A gate that reports speech or not for each frame, usually from its level and its shape.
  5. The listener. A speech recogniser, or an audio-native model, receives the cleaned stream.
  6. Stop signal. If the VAD hears speech for a hang time, say 150 ms, the robot flushes its playback buffer and goes quiet.

Why the gate needs a clean signal

The VAD has a threshold: a level that sound must pass to count as speech. Set it high and a soft-spoken user is missed. Set it low and anything above a whisper trips it, including leftover echo. With no echo canceller, the robot’s own voice at the microphone is usually louder than you. No threshold can tell the two apart by level. The robot either never stops, or it stops itself on its own first syllable.

The echo canceller opens a gap. After it, the robot’s voice is quieter by the ERLE. Now there is room for a threshold between the leftover echo and a quiet person. The condition is simple: residual echo level < threshold < your level.

Work it with illustrative numbers. The robot’s loudest syllable reaches the microphone at −20 dBFS (dB below the largest value the converter can store). The VAD threshold is −45 dBFS. The residual echo must be under −45, so the ERLE must be above 25 dB. With a few dB of safety, the target is about 30 dB. Your voice at −34 dBFS is 11 dB over the threshold, so it triggers the stop.

Interrupt the robot

The robot speaks from 0 s. You start talking at 1.6 s. The dashed line is the VAD threshold. Purple is what is left of the robot, teal is you. Change the echo reduction and your loudness.

35 dB
-34 dBFS

Illustrative levels: the robot’s loudest syllable is −20 dBFS at the microphone, both voices follow a 0.7 s syllable rhythm, the VAD threshold is −45 dBFS, and the robot cuts speech 0.21 s after the VAD fires (150 ms hang time plus 60 ms to flush the buffer). Real VADs use shape as well as level.

At 35 dB of reduction the residual echo peaks at −55 dBFS, well under the line, and you stop the robot about a fifth of a second after you start. Drag the reduction down to 10. The echo crosses the threshold on the robot’s first loud syllable, and the robot cuts itself off before you said a word. Raise the reduction to 50, and quiet your voice to −48: now the echo is gone but you are below the threshold, and the robot talks on. Both ends of the gap matter.

Full-duplex models make it stricter

Newer systems feed the microphone stream straight into an audio model that speaks and listens at once. That model has no separate gate. It reads whatever the microphone gives it. If robot echo leaks through, the model may think you are speaking and stop, answer its own sentence, or enter a loop where it replies to itself. An echo canceller is not an extra for these systems. It is the thing that stops the model from hearing itself.

One more rule from the pipeline: the reference must match what was actually played. When the robot cuts speech, a buffer of audio may still be in flight, and its echo keeps arriving for tens of milliseconds. If you clear the reference too early, the canceller sees echo with no source, and that echo trips the VAD again. Keep feeding the reference until the last played sample has gone through the speaker.

Failure, then measurement, then fix. The symptom: the robot stops by itself, or talks over you when you speak quietly. The measurement: plot the VAD input level against time with the robot speaking and nobody else in the room. The peak of that plot is your residual echo level. The fix: get the ERLE high enough that the peak sits below the threshold with margin, using the earlier chapters, in order of cost. Then set the threshold from measurement, not from a guess.

The leftover echo peaks at −50 dBFS, the VAD threshold is −45 dBFS, and you speak at −40 dBFS. What happens when you interrupt?

Chapter 10

The Field Guide

Keep the numbers, the checklist and the code, and follow the links to the sources

A robot that talks hears its own voice as an echo of known shape. A canceller learns the room as a list of taps, predicts the echo from the reference, and subtracts it. NLMS teaches the taps. Frequency-domain blocks make long rooms cheap. Double-talk needs a protected step size. A suppressor sweeps up the rest. Loud speakers need a model or a limiter. Delay needs measuring all the time. All of it exists so that the robot can listen while it speaks, and stop when you interrupt.

The numbers

QuantityValueWhere it comes from
Desk echo delay, 15 cm0.44 msDistance over 343 m/s (Chapter 0)
Echo return loss assumed by the phone standardat least 6 dBITU-T G.168 as quoted in a Zarlink datasheet
Typical ERLE of a canceller18 to 35 dBEcho cancellation overview (Wikipedia)
NLMS stability0 < μ < 2; error shrinks by (1 − μ)Derived in Chapter 3; bound in the LMS reference
Extra error from noise (white input)μ / (2 − μ) of the noise powerTextbook result; trend only for speech
Taps for a 0.4 s room at 16 kHz6,4000.4 × 16,000 (Chapter 1)
ERLE ceiling of a short filter60 · Tc / RT60 dBDerived in Chapter 4 for an exponential tail
Cost per sample, time vs frequency2L vs 10 log2(2L) + 8A rough model used in this lesson, not a benchmark
Geigel threshold0.5 of the far-end peak (−6 dB)Tied to the 6 dB path loss above
Soft-step maximum, and its gain over detectorsμmax 0.5; over 4 dB ERLE on averageValin 2007
No protection fails when you are louder than the echo by10 dB or moreValin 2007, the no-detection baseline
Clock drift of 100 ppm at 16 kHz1.6 samples a second16,000 × 100 × 10−6 (Chapter 8)
ERLE needed for barge-in in the toyabove 25 dB−20 dBFS echo against a −45 dBFS gate (illustrative)

The checklist

  1. Tap the reference late. Take it after volume and the limiter, from a loopback if you can.
  2. Measure the delay. Correlate reference and microphone, hold the reference back with a margin, and keep measuring.
  3. Cover the tail. Filter length at least the time for the echo to fall to the level you can hear. Check ERLE against 60 · Tc / RT60.
  4. Work in blocks of short partitions. Frequency domain for cost, small blocks for delay.
  5. Protect the step. Use a soft step or a detector. Make the step bigger after a sudden change.
  6. Cap the speaker level. Add a limiter. Sweep the volume and plot ERLE.
  7. Add a suppressor last. Tune its strength on double-talk speech, and measure the damage to your own voice.
  8. Set the gate from data. Record the robot talking alone. Place the VAD threshold above that peak with margin.

The core as code

pythonimport numpy as np

def aec_nlms(x, d, L=64, mu=0.5, eps=1e-6, thr=0.5):
    """x: reference sent to the speaker (T,). d: microphone (T,). Returns e (T,), y_hat (T,)."""
    T = len(x)
    w = np.zeros(L)                                  # the filter, shape (L,)
    xp = np.concatenate([np.zeros(L - 1), x])        # pad so every window has L samples
    y_hat, e = np.zeros(T), np.zeros(T)
    hold = 0
    for n in range(T):
        xb = xp[n:n + L][::-1]                       # newest sample first, shape (L,)
        y_hat[n] = w @ xb                            # predict the echo
        e[n] = d[n] - y_hat[n]                       # subtract: this is the cleaned output
        if abs(d[n]) > thr * np.abs(xb).max():       # Geigel: mic louder than echo can be
            hold = int(1.5 * L)                      # so someone else is talking: freeze
        if hold > 0:
            hold -= 1
        else:
            w += mu * e[n] * xb / (xb @ xb + eps)    # the NLMS nudge (Chapter 3)
    return e, y_hat

def erle_db(echo, y_hat):
    return 10 * np.log10(np.sum(echo ** 2) / (np.sum((echo - y_hat) ** 2) + 1e-12))

if __name__ == "__main__":
    rng = np.random.default_rng(0)
    T, L = 16000, 64
    x = np.convolve(rng.standard_normal(T), [1, 0.8, 0.5])[:T]        # coloured reference
    h = np.zeros(L); h[6] = 0.3; h[7:40] = 0.05 * rng.standard_normal(33) * np.exp(-np.arange(33) / 10)
    echo = np.convolve(x, h)[:T]
    d = echo + 0.002 * rng.standard_normal(T)
    e, y_hat = aec_nlms(x, d, L)
    print("ERLE over the last second: %.1f dB" % erle_db(echo[-8000:], y_hat[-8000:]))

On the synthetic data in the script, it prints an ERLE of 52.0 dB over the last second. That figure comes from a nearly noise-free toy, so it is much higher than a real room. Add noise, a longer tail or a distorting speaker, and watch it fall.

Where it sits in the field

Echo cancellation is the first stage of a robot’s ears. After it come the microphone array (beamforming), noise suppression and the voice-activity detector. They hand clean audio to the speech model, and the turn-taking logic decides when to speak (voice turn-taking). The filter maths here is the same family as the adaptive filters lesson. The measurement side of the echo path is in room acoustics measurement.

Keep going

Sources

I opened the first four pages and read the rest through search results, so check the original before you rely on an exact figure from them.

The takeaway. The robot knows what it said, so it can learn what the room did to it and take that away. Everything else is about keeping that learning honest: when you talk, when the speaker bends, when the delay moves, and when the leftover is still louder than a whisper.

Now press Teach and explain, on the whiteboard, how the filter learns the room, why your voice hurts it, and what a suppressor adds. Then go back to the canceller at the top, raise the room echo, and say why it still keeps your voice.

A robot cancels well on the bench, then fails when its audio goes over Bluetooth. What do you check first?
Acoustic Echo Cancellation
Back to Gleams