MSP Tutorials
Polyphony Tutorial 3: Audio-Rate Control Data
Low-frequency oscillators
This tutorial looks at using the poly~ object to generate
low-frequency oscillators (LFOs) to generate control-rate data for
Max objects. There are many tasks in Max (such as graphics) that don't
require control updates at audio rate (44,100 per second, or higher),
and simply need to receive new values regularly at a lower speed. For
example, a video processing patcher running at 30 frames per second
would only need new information for all of its parameters every 33
milliseconds. At the same time, MSP signal generators make excellent
choices for designing periodic sources of control information.
The poly~ object has a simple way to downsample the audio
processing in an abstraction, so that it can be used to create control-rate
data in Max without the CPU overhead of working at audio rate.
Take a look at the tutorial patcher. Turn on the dac~ (on the right)
and the metro (on the left) using the toggle objects. You
should see a line being drawn in the lcd object on the right of
the patcher. At any point, you can hit the space bar to clear the
drawing.
In the number boxes labeled X and Y, type 1. and 1.3,
respectively. Look at the curve drawn in the lcd. Clear the lcd
with the space bar and change the values to 1. and 4.. Notice
that when the values are in an integer ratio the pattern begins redrawing itself
after a while. Try your own numbers, or changing them as they go.
Using cosine waves of different frequencies as the X and Y inputs of a drawing
surface (such as an oscilloscope) creates something called lissajous curves.
These patterns visually describe complex harmonic motion, so that X and Y
patterns in simple ratios will create pre-determined repeating shapes.
Using snapshot~
Double-click one of the poly~ objects to see inside
the polylfo1~ abstraction.
Notice how simple our abstraction seems, with an in object
allowing use to set the frequency of a cycle~ object. A
second in object provides bang messages to
a snapshot~. The snapshot~ object allows us to
capture single values of MSP signals as floating-point numbers
generated as Max events. Whenever a snapshot~ receives
a bang, it samples the current MSP signal at its
inlet and outputs that one sample as a floating-point value.
In our tutorial, this value then goes to an out object,
and back into our main patcher.
Changing abstractions
Close the abstraction polylfo1~ and return to the main
tutorial patcher. Click on the message boxes in the middle
that begin with the message patchername. The patchername
message reloads a poly~ object with a new abstraction.
Notice the effect on the drawing, depending on which you select and
whether it applies to the X or Y poly~ object.
Select polylfo2~ and double-click the poly~ object to
see it.
The polylfo2~ abstraction does the same as polylfo1~,
but generates its output as a sawtooth wave rather than a cosine wave.
The phasor~ object generates ramps from 0 to 1,
so we scale the output to go between -1 and 1 with
the *~ and -~ objects before we sample it with
the snapshot~
Switch one of the poly~ objects to polylfo3~ and look inside.
The polylfo3~ object generats a triangular output by using
a triangle~ object. The triangle~ object wraps
a phasor~ around a midpoint, essentially translating it
into a triangular waveform. This object outputs values between -1
and 1, so it doesn't require any scaling.
Resampling arguments
Close any open abstractions and return to the main patcher. Look at
the arguments to the poly~ objects.
When working with an abstraction inside of a poly~ object,
you can decide to work at a lower or higher sampling rate
than your main MSP patcher. This rate is not specified directly,
but as a divisor or multiplier of the main rate. The arguments up 2
will make the poly~ run at twice the sampling rate of the
main patcher. The arguments down 8, as shown here, run the
audio within the poly~ objects at one eighth the
normal speed (i.e. 5.5125kHz if the main patcher runs at 44.1kHz).
Since we're only sampling our oscillator values once every frame
of the drawing (set by the metro speed at 50Hz or every 20ms),
this is more than enough resolution for our control data.
Mix and match different LFO curves by choosing different poly~
abstractions run at different frequencies. Notice how the Lissajous
curves behave with the different waveforms.
Summary
The poly~ object can work at a different sampling rate than
its host MSP patcher. The up and down arguments allow
you to specify a multiplier or divisor for the main sampling rate.
When designing LFOs (low frequency oscillators), it's often useful
to use massively downsampled MSP patchers inside of poly~
objects to generate the curves efficiently. the snapshot~
object allows you to sample a single value from an MSP signal in
response to a bang.
Convert signal values to numbers