Gamma: Simple Reverb

From cmwiki
Jump to: navigation, search

Disclaimer

The official website for Gamma is http://mat.ucsb.edu/gamma.

This is NOT an official gamma website. Everything HERE is just random scribblings by people trying to understand gamma--and might be inaccurate, out of date, or just plain wrong. You have been warned.


A simple Echo effect

The Gamma tutorial contains some code that creates a simple echo effect, but it may not be immediately obvious how to use that code if you aren't familiar with some of the internal details of Gamma. So here is a simpler version that can be applied to any of the Synths from MAT276IA.

This echo effect using a single comb filter, so it is not at all an example of "best practice" for reverb, but it is a reasonable starting point if you just want your sound to be a little less dead and dry, and you are relatively new to signal processing, filter design, etc.

Step 1: Add this near the top of your file

If you are working with one of the synths from MAT276IA, somewhere near the top of your code, you have something like this (this example is from Media:synth1.cpp): 

class SineEnv : public Process {
...

or one of these:

Just ABOVE that line of code, copy and paste all of the following (this comes from [Section 3.6 of the Gamma Tutorial, v. 0.9.5]) 

struct Echo : public Process {
  Echo(): echo(0.4, 0.323, 0, 0.8){}
  void onProcess(AudioIOData& io){
    while(io()) {
      float2 s = float2(io.out(0), io.out(1));
      s = echo(s)*0.5;
      io.out(0) += s[0];
      io.out(1) += s[1];
    }
  }
  Comb<float2> echo;
};

Now, in the main, you probably have a line of code like this: 

 Scheduler s;

Immediately AFTER that line of code, simply add the following: 

 s.add<Echo>();

And, that's all there is to it. Try listening to your piece with that line present, and with that line commented out, e.g. 

 // s.add<Echo>();

You should hear a little bit of echo after each sound.

Nice! But what if want to "turn the knobs" on this little effect?

The parameters of the comb filter that is being applied to the signal are controlled by this line of

Our echo effect is really just a single "comb filter". So to alter the effect, we need to alter the parameters of that comb filter.

We can find those in the code in the block you pasted in at the top—a block of code that defines a struct Echo as inheriting from the class Process.

The specific line that we need to look at is this one: 

  Echo(): echo(0.4, 0.323, 0, 0.8){}

But what do these numbers mean? The key to unlocking that mystery (and many others in Gamma) is to understand what's going on in the C++ code:

  • On this line of code, the variable echo (note lowercase) is being initialized in the constructor for the struct Echo (note uppercase).
  • lowercase echo is an instance of the class Comb (see further down, near the end of the struct definition)
  • We therefore need to find a constructor for Comb that takes four numeric parameters, and learn what each of those parameters controls.

We can either search through the source code for the definition of Comb (which is found in Gamma/Delay.h), or we can use the Doxygen generated documentation, found at this link:

In case the link breaks later, here's what the source code says about those parameters: 

        /// @param[in]	maxDelay	Maximum delay length. The size of the delay line 
	///							will be the smallest possible power of two.
	/// @param[in]	delay		Delay length
	/// @param[in]	ffd			Feedforward amount, in [-1, 1]
	/// @param[in]	fbk			Feedback amount, in (-1, 1)
	Comb(float maxDelay, float delay, const Tp& ffd, const Tp& fbk);

You can find other methods there that you can use to control the comb filter as well, including these: 

        /// Set number of units for response to decay to end value
	/// The sign of the decay length determines the sign of the feedback coefficient.
	/// The default end value of 0.001 (-60 dB) is the reverberation time of 
	/// the filter.  Setting the decay amount effects only the feedback value.
	/// The decay must be updated whenever the delay length of the filter changes.
	void decay(float units, float end = 0.001f);

	/// Sets feedback to argument and feedforward to argument negated
	void allPass(const Tp& v);

	void fbk(const Tp& v);					///< Set feedback amount, in (-1, 1)
	void ffd(const Tp& v);					///< Set feedforward amount [-1, 1]
	void feeds(const Tp& fwd, const Tp& bwd){ ffd(fwd); fbk(bwd); }

	void set(float delay, const Tp& ffd, const Tp& fbk); ///< Set several parameters

Some articles on Reverb

Retrieved from "https://foo.cs.ucsb.edu/cmwiki/index.php?title=Gamma:_Simple_Reverb&oldid=50"