Getting to the Frequency Domain: In Practice

How do we get from the time domain to the frequency domain in Max? There are two tutorials, Using the FFT and Signal Processing with pfft~, that describe this process in great detail. Read at least the first of these—Using the FFT—which provides a conceptual overview. However, the first tutorial focuses mostly on the fft~ object, which is simpler but less useful in practice. The second tutorial is more technical, showing how to do spectral processing with the pfft~ object in Max/MSP; try out the processes in the tutorial, even if you don't understand every bit of it.

What follows here are some mini-tutorials, in an attempt to further simplify some of the material in the more wide-ranging tutorials linked above.

Mini-Tutorial 1: Visualizing the Frequency Spectrum

Quick vocab review: when discussing timbre, and the relative strength of the sine tones that compose a given pitch, we can refer to the totality of a sound's frequency-to-magnitude mappings as its "spectrum". Put more simply, do you remember that visualization of the frequency domain, with frequency on the x axis and magnitude on the y axis? That's called a "spectrum". In Max, we can visualize a spectrum of a sound with the object spectroscope~.

The spectroscope~ object, in "spectrogram" mode.

The spectroscope~ object has two modes: spectrogram and sonogram. The spectrogram is what we've been discussing: a snapshot of magnitude over frequency. The sonogram is actually a map of frequency over time, with high frequencies at the top of the y axis and low frequencies at the bottom of the y axis. Dark points represent louder frequencies, while lighter points represent softer ones.

The spectroscope~ object, in "sonogram" mode.

To switch between spectrogram and sonogram modes, change the "Display Mode" attribute in the inspector window.

Mini-Tutorial 2: How to Use pfft~

Pfft~

(Text for all three videos)

This video will help you gain some practical experience with the Fourier Transform in Max. We will do this using the PFFT~ object, which is essentially a spectral processing manager.

Spectral processing tools and workflows are most useful when you have a good understanding of what is happening to the data signals. So, if you haven’t already become familiar with the basics of the Fourier Transform, do so now by visiting the links in the introduction of this page.

If we want to use PFFT, we need two maxpatches. So let’s create a project to make this easy.

Go to File > New Project.

Save your project as “FourierFun”

You will see this project manager window appear. Add a new file to the project by clicking the “+” button located at the bottom left corner.

Name the file “FourierFun_MAIN.”

Let’s add our second file the same way. This time, let’s name the file “FourierFun_pfft.” This is where our spectral processes will be defined.

Let’s set up our “FourierFun_MAIN” patch for the pfft object. We’ll add some objects that will help us debug and understand what is going on inside the pfft patch.

Create a cycle~ object. Route this signal through live.gain, an into an EZdac.

We will drive the frequency of this object with a phasor set to .5 hz.

Route this control signal through a scale~ object. Phasor outputs values from 0 to 1. We want to scale this from 100 to 10000. This will give us a good range of frequencies to mess around with.

Then route the signal into the first cycle~. Test your audio to make sure it sounds correct.

Now we can move onto the PFFT object.

Our goal will be to isolate a frequency that we specify. You’ll soon see that this goal has its limits.

Create a pfft object. The first argument is the filename of our pfft patch, “FourierFun_pfft.”

Next is our desired frame size. We’ll use 1024 for now.

The last argument is the overlap factor, which we’ll set as 4.

Route the PFFT object between the second cycle~ and live.gain.

Now we can open the pfft patch. Similar to a subpatch, we need to designate ins and outs. PFFT has special ins and outs.

Create the object fftin~ 1. Any signal sent into the PFFT object located in our main patch will be routed through here and output as FFT coefficients for each frequency bin. These are labeled “real” and “imaginary.”

To attempt isolating a frequency, we need to affect the magnitude of a frequency bin. To get this data, create a cartopol~ object, and connect both outputs of fftin~ 1 to its inputs.

Before we mess with the data streams, lets convert them back into real and imaginary streams, then send them to an fftout~ 1 object.

To finish our setup, add an “in 2” object and “out 1.” Make an fftinfo~ object and connect its first output to “out 1.” We’ll use this data later.

Save your patch and test the audio. You may need to reload your pfft~ object in the main patch.

Notice the audio comes through clean. We have successfully exposed the frequency spectrum which we can now manipulate.

Move back to the pfft patch. Remember, our goal is to attempt to isolate a specified frequency from an audio signal. So where do we find the frequency data?

The simple answer is this third outlet on fftin~ 1. Here we are given the bin index of the current magnitude and phase values. We can get the frequency value of a bin by multiplying its index by the bin spacing value. We get the spacing by dividing the sampling rate by the frame size.

Knowing this, we’ll need to alter our goal a little. We can’t really just tell the pfft object to spit out a single frequency. Instead, we need to specify a bin.

We’ll test the bin value against our specified value using an ==~ object. Connect the outlet out in 2 to the right input of ==~. Then connect the bin index to its left.

This object will send a 1 when true and a 0 when false. If we multiply this by the magnitude value, we will have eliminated any frequency data that is not from our specified bin.

Save this patch and move on over to our Main patch. Connect an integer to the right inlet of pfft~ and choose a bin value. The result is a repeating blip of pitched audio. If you’re unsure of exactly why this is happening, that’s alright. Let’s add a few objects to deepen our understanding.

Pfft~ video 1

Pfft~ video 2

Pfft~ video 3

The pfft~ object has a number of unusual quirks. The first is that its first argument is the name of a Max patch. That's right: for pfft~ to work, you need to create completely separate, secondary Max patch that contains all of the frequency-domain processing you want to do. A common convention is to postfix the filename of this secondary Max patch with "_pfft" so that other programmers understand what the patch is doing. For example, you might have a patch called "spectral_gate.maxpat", which contains the object pfft~ spectral_gate_pfft.maxpat. So long as "spectral_gate_pfft.maxpat" is in same folder or elsewhere on the search path, the pfft~ will function correctly.

The second argument of pfft~ is the FFT frame size. Review the previous lession if you're unsure what this means. To review, this must be a power of 2, and the most common values are 1024, 2048, and 4096.

The third argument of pfft~ is the overlap factor. One way to counteract the time-resolution/frequency-resolution tradeoff described in the previous lession is to have FFT frames overlap with one another. Usually this overlap factor is fairly small, somewhere around 4.

That's it for pfft~ arguments! Now let's move on now to the interior Max patch—the one that actually does the pfft~ processing.

To change the number of inlets and outlets of pfft~, create fftin~ and fftout~ objects. These take one required argument: the (1-indexed) order of inlet/outlet the object corresponds to on the outer-level. So, if you want to create a pfft~ with two inlets and one outlet, create the objects fftin~ 1, fftin~ 2, and fftout~ 1.

If you look at the three outlets of an fftin~, you'll see the leftmost is labeled "Real Input", the middle is labeled "Imaginary Input", and the rightmost is labeled "FFT Bin Index". For the first two—real and imaginary—these correspond to what are called the "cosine coefficient" and "sine coefficient" of each frequency bin of the FFT. Unless you really know what you're doing, these coefficients will be of little use to you. To get the magnitude of each frequency bin—what you're probably really looking for—you have to run both the real and imaginary inputs through a cartopol~ object. Then, the left outlet of cartopol~ will correspond to magnitude, while the right outlet of cartopol~ will correspond to phase.

When done playing around with magnitude and phase values, don't forgot to run those values back through a poltocar~ before passing them to fftout~!

Finally, the "FFT Bin Index" outlet of fftin~ tells you which bin the corresponding cosine and sine coefficients belong to. One quirk of this is that this bin index only goes up to half the FFT size. So, if your FFT size is 4096, the FFT bin index will top out at 2047. This is because the frequencies from bins 2048 through 4095 will be above the Nyquist frequency, and so are of no use for us. To review what the Nyquist frequency is, reread Prof. Dobrian's Digital Audio article.

Mini-Tutorial 3: Creating a Spectral Gate

Let's compose a cool audio effect that's only possible by translating to and from the frequency domain: a "spectral gate". Whereas a "noise gate" takes an input signal, and only lets amplitude values pass through that are above a given threshold, a spectral gate takes an input signal, and only lets frequency bins pass through whose magnitudes are above a given threshold. You can download this example below.

Outer-level spectral gate patch

View of spectral_gate_pfft.maxpat

Downloads

spectral_gate.zip

Additional Resources

There are two Max Cookbook examples concerning the FFT: