Echo Effect with Circular Buffer

1. The Anatomy of an Echo

At its core, an echo is a repetition of a sound that occurs after a delay. In the digital world, we can create this effect by storing an audio signal and playing it back later. To create the characteristic decaying echoes, we can feed a portion of the delayed signal back into the delay's input. This structure is known as a feedback comb filter.

The video below explains the core signal processing block diagram for a simple digital delay.

The Difference Equation

As you saw in the video, the feedback structure can be described mathematically. Let's analyze the most common and simple form of a feedback delay, also known as a feedback comb filter.

A common structure for a simple echo effect. The input is summed with a fed-back, attenuated version of the delayed signal. This combined signal is then stored in the delay line. The final output is a mix of the original (dry) and delayed (wet) signals.

From this diagram, we can derive the difference equations:

1. The signal going into the delay line, let's call it $w[n]$, is the sum of the current input sample $x[n]$ and the scaled output of the delay line from the previous step. The output of a delay line of length $D$ is the signal that was fed into it $D$ samples ago. Therefore:
   $w[n]=x[n]+g\cdot w[n-D]$
   where $g$ is the feedback gain.

2. The final output of the effect, $y[n]$, is a mix of the original "dry" input signal $x[n]$ and the "wet" signal coming out of the delay line, which is $w[n-D]$.
   $y[n]=(1-m)\cdot x[n]+m\cdot w[n-D]$
   where $m$ is the mix level (from 0 for fully dry to 1 for fully wet).

Your electrical engineering background will recognize the first equation as a first-order infinite impulse response (IIR) filter, where the "pole" is determined by the feedback gain $g$. For the system to be stable (i.e., for the echoes to decay and not grow infinitely loud), the magnitude of the feedback gain must be less than 1 ($|g|<1$).

2. The Circular Buffer: An Essential Data Structure

To implement the delay $w[n-D]$, we need to store a history of the signal $w[n]$. A standard audio buffer passed to our processing function is not suitable, as its contents are overwritten with each new block of audio. We need a separate, much larger buffer—the delay line—to store samples for potentially long periods.

A simple array could work, but managing it would be inefficient. We would have to shift all the samples in the array every time a new sample arrives to make room at the front. A far more efficient solution is the circular buffer (also called a ring buffer).

A circular buffer is a fixed-size array treated as if its end connects back to its beginning. We don't move any data. Instead, we use a "write pointer" (or index) that moves through the array, wrapping back to the start when it reaches the end. This elegantly solves the problem of continuously storing and retrieving the most recent samples.

3. Implementing the Echo with a Circular Buffer

Now, let's combine the signal processing theory with the circular buffer data structure. The implementation requires managing the buffer and applying the difference equation sample by sample.

The Algorithm

For each incoming audio sample input_sample, the process is as follows:

1. Establish pointers/indices: You need a write_index that points to the current position in the circular buffer. This index increments with every sample. The size of the circular buffer, buffer_size, should be large enough to accommodate the maximum desired delay.

2. Calculate the read index: The "wet" signal is the sample that was written D samples ago. Its location is found by subtracting the delay length D (in samples) from the current write_index. We use modulo arithmetic to handle the "wrap-around".
   read_index = (write_index - D + buffer_size) % buffer_size;
   (Adding buffer_size before the modulo ensures the result is always positive, which is important in some languages like C++ where % can yield negative numbers for negative inputs).

3. Read the delayed sample: Get the "wet" signal from the buffer.
   delayed_sample = circular_buffer[read_index];

4. Calculate the value to write: Based on our feedback equation, compute the new sample that goes into the delay line.
   value_to_write = input_sample + feedback_gain * delayed_sample;

5. Write to the buffer: Store this new value at the current write position.
   circular_buffer[write_index] = value_to_write;

6. Calculate the final output: Mix the dry input and the wet delayed signal.
   output_sample = (1 - mix) * input_sample + mix * delayed_sample;

7. Update the write index: Move the write index to the next position for the next sample.
   write_index = (write_index + 1) % buffer_size;

The following pseudo-code from a Texas Instruments application note shows a very concise version of this processing loop.

To see this all come together in a full C++ implementation, the following resource is excellent.

Conclusion

Congratulations! You've now grasped the theory and implementation of one of the most fundamental audio effects. The concepts you've learned today are the bedrock for a wide array of more complex time-based effects.

Key Takeaways:

• A simple echo effect is created using a feedback delay structure, which is a type of IIR comb filter.
• The key parameters are delay time (in samples), feedback gain (controls decay), and wet/dry mix.
• A circular buffer is the efficient data structure used to implement the digital delay line, avoiding costly data shifting by using a wrapping write pointer.
• The core algorithm involves reading a past sample from the buffer, calculating a new sample using the feedback equation, writing the new sample back to the buffer, and advancing the write pointer.

Preview of the Next Lesson:

What happens if the delay time D is not fixed? In the next lesson, we will explore this by learning to develop a chorus or flanger effect by modulating the delay time of a delay line with a low-frequency oscillator (LFO). This will build directly upon the circular buffer and delay line structure you've learned to implement today.