Have you ever wondered how a reverb filter works? I have... and here's what I came up with.
Reverb is the sound effect you commonly get when you make sound inside a room or building, as opposed to when you are outdoors. The stairwell in my old apartment building had an excellent reverb. Most live musicians hate reverb because it muddles the sound they're trying to create and can even throw them off while playing. On the other hand, reverb is very often used (and overused) in the studio vocals because it also has the effect of smoothing out rough edges and imperfections in a recording.
We typically distinguish reverb from echo in that an echo is a single delayed "replay" of the original sound you made. The delay is also typically rather large (think yelling into a distant hill- or mountainside and hearing your HEY! come back a second or more later). In more detail, the two things that distinguish reverb from an echo are:
- The reverb inside a room or a hall has a much shorter delay than an echo. The speed of sound is roughly 340 meters/second, so if you're in the middle of a room that is 20 meters by 20 meters, the sound will come back to you (from one wall) after (20 / 2) / 340 = ~0.029 seconds, which is such a short duration of time that we can hardly notice it (by comparison, a 30 FPS video would display each frame for ~0.033 seconds).
- After bouncing off one wall, the sound reflects back and reflects off the other wall. It also reflects off the perpendicular walls and any and all objects that are in the room. Even more, the sound has to travel slightly longer to reach the corners of the room (~14 meters instead of 10). All these echoes themselves go on to combine and echo off all the other surfaces in the room until all the energy of the original sound has dissipated.
Intuitively, it should be possible to use multiple echoes at different delays to simulate reverb.
We can implement a single echo using a very simple ring buffer:
class FeedbackBuffer {
public:
unsigned int nr_samples;
int16_t *samples;
unsigned int pos;
FeedbackBuffer(unsigned int nr_samples):
nr_samples(nr_samples),
samples(new int16_t[nr_samples]),
pos(0)
{
}
~FeedbackBuffer()
{
delete[] samples;
}
int16_t get() const
{
return samples[pos];
}
void add(int16_t sample)
{
samples[pos] = sample;
/* If we reach the end of the buffer, wrap around */
if (++pos == nr_samples)
pos = 0;
}
};
The constructor takes one argument: the number of samples in the buffer, which is exactly how much time we will delay the signal by; when we write a sample to the buffer using the add() function, it will come back after a delay of exactly nr_samples using the get() function. Easy, right?
Since this is an audio filter, we need to be able to read an input signal and write an output signal. For simplicity, I'm going to use stdin and stdout for this -- we will read 8 KiB at a time using read(), process that, and then use write() to output the result. It will look something like this:
#include <cstdio>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
int main(int argc, char *argv[])
{
while (true) {
int16_t buf[8192];
ssize_t in = read(STDIN_FILENO, buf, sizeof(buf));
if (in == -1) {
/* Error */
return 1;
}
if (in == 0) {
/* EOF */
break;
}
for (unsigned int j = 0; j < in / sizeof(*buf); ++j) {
/* TODO: Apply filter to each sample here */
}
write(STDOUT_FILENO, buf, in);
}
return 0;
}
On Linux you can use e.g. 'arecord' to get samples from the microphone and 'aplay' to play samples on the speakers, and you can do the whole thing on the command line:
$ arecord -t raw -c 1 -f s16 -r 44100 |\
./reverb | aplay -t raw -c 1 -f s16 -r 44100
(-c means 1 channel; -f s16 means "signed 16-bit" which corresponds to the int16_t type we've used for our buffers; -r 44100 means a sample rate of 44100 samples per second; and ./reverb is the name of our executable.)
So how do we use class FeedbackBuffer to generate the reverb effect?
Remember how I said that reverb is essentially many echoes? Let's add a few of them at the top of main():
FeedbackBuffer fb0(1229);
FeedbackBuffer fb1(1559);
FeedbackBuffer fb2(1907);
FeedbackBuffer fb3(4057);
FeedbackBuffer fb4(8117);
FeedbackBuffer fb5(8311);
FeedbackBuffer fb6(9931);
The buffer sizes that I've chosen here are somewhat arbitrary (I played with a bunch of different combinations and this sounded okay to me). But I used this as a rough guideline: simulating the 20m-by-20m room at a sample rate of 44100 samples per second means we would need delays roughly on the order of 44100 / (20 / 340) = 2594 samples.
Another thing to keep in mind is that we generally do not want our feedback buffers to be multiples of each other. The reason for this is that it creates a consonance between them and will cause certain frequencies to be amplified much more than others. As an example, if you count from 1 to 500 (and continue again from 1), and you have a friend who counts from 1 to 1000 (and continues again from 1), then you would start out 1-1, 2-2, 3-3, etc. up to 500-500, then you would go 1-501, 2-502, 3-504, etc. up to 500-1000. But then, as you both wrap around, you start at 1-1 again. And your friend will always be on 1 when you are on 1. This has everything to do with periodicity and -- in fact -- prime numbers! If you want to maximise the combined period of two counters, you have to make sure that they are relatively coprime, i.e. that they don't share any common factors. The easiest way to achieve this is to only pick prime numbers to start with, so that's what I did for my feedback buffers above.
Having created the feedback buffers (which each represent one echo of the original sound), it's time to put them to use. The effect I want to create is not simply overlaying echoes at fixed intervals, but to have the echos bounce off each other and feed back into each other. The way we do this is by first combining them into the output signal... (since we have 8 signals to combine including the original one, I give each one a 1/8 weight)
float x = .125 * buf[j];
x += .125 * fb0.get();
x += .125 * fb1.get();
x += .125 * fb2.get();
x += .125 * fb3.get();
x += .125 * fb4.get();
x += .125 * fb5.get();
x += .125 * fb6.get();
int16_t out = x;
...then feeding the result back into each of them:
fb0.add(out);
fb1.add(out);
fb2.add(out);
fb3.add(out);
fb4.add(out);
fb5.add(out);
fb6.add(out);
And finally we also write the result back into the buffer. I found that the original signal loses some of its power, so I use a factor 4 gain to bring it roughly back to its original strength; this number is an arbitrary choice by me, I don't have any specific calculations to support it:
buf[j] = 4 * out;
That's it! 88 lines of code is enough to write a very basic reverb filter from first principles. Be careful when you run it, though, even the smallest mistake could cause very loud and unpleasant sounds to be played.
If you play with different buffer sizes or a different number of feedback buffers, let me know if you discover anything interesting :-)
11 comments:
Great tutorial......thanks very much
Why I don't see internet breaking the speakers every now and then if they can be broken by programming?
I'm sure you've heard of blowing out speakers, the problem is that bad programming makes it that much easier to make it happen if you're not careful in turning down the volume quite a bit.
If you need to get the data from the start. And all the techniques is here then this is good for all the my site readers. They way they write this blog is the best way to show us some data.
There is the reverb filter from the first principles and you can get your help in this zone. Just get a better place here too Click here for the Grep Vegard and lessen the risk for your work which is a good thing.
Post a Comment