MSP Tutorial 13: Recording and Playback Página 1 de 4

Tutorial 13: Recording and Playback

Open the tutorial.

Sound input: adc~

For getting sound from the ‘real world’ into MSP, there is an analog-to-digital conversion object called
adc~. It recognizes all the same messages as the dac~ object, but instead of sending signal to the
audio output jacks of the computer, adc~ receives signal from the audio input jacks, and sends the
incoming signal out its outlets. Just as dac~ has a user interface version called ezdac~, there is an
iconic version of adc~ called ezadc~.

adc~ and ezadc~ get sound from the audio input jacks and send it out as a signal

To use the adc~ object, you need to send sound from some source into the computer. The sound may
come from the CD player of your computer, from any line level source such as a tape player, or from a
microphone -- your computer might have a built-in microphone, or you can use a standard
microphone via a preamplifer.

• • Double click on the adc~ object to open the DSP Status window. Make sure that the Input Source
popup menu displays the input device you want. Depending on your computer system, audio card and
driver, you may not have a choice of input device-this is nothing to be concerned about.

• • Click on the toggle above the adc~ object to turn audio on. If you want to hear the input sound
played directly out the output jacks, adjust the number box marked Audio thruput level.

Adjust the audio throughput to a comfortable listening level

If your input source is a microphone, you'll need to be careful not to let the output sound from your
computer feed back into the microphone.

Recording a sound: record~

To record a sample of the incoming sound (or any signal), you first need to designate a buffer in
which the sound will be stored. Your patch should therefore include at least one buffer~ object. You
also need a record~ object with the same name as the buffer~. The sound that you want to record
must go in the inlet of the record~ object.

file:///C:/Program%20Files/Cycling%20'74/Max%205.0/patches/docs/tutorials/msp-tu... 21/09/2017
MSP Tutorial 13: Recording and Playback Página 2 de 4

Record two seconds of stereo sound into the buffer~ named soundbite

When record~ receives a non-zero int in its left inlet, it begins recording the signals connected to its
record inlets; 0 stops the recording. You can specify recording start and end points within the buffer~
by sending numbers in the two right inlets of record~. If you don't specify start and end points,
recording will fill the entire buffer~. Notice that the length of the recording is limited by the length of
the buffer~. If this were not the case, there would be the risk that record~ might be left on
accidentally and fill the entire application memory.

In the tutorial patch, record~ will stop recording after 2 seconds (2000 ms). We have included a
delayed bang to turn off the toggle after two seconds, but this is just to make the toggle accurately
display the state of record~. It is not necessary to stop record~ explicitly, because it will stop
automatically when it reaches its end point or the end of the buffer~.

A delayed bang turns off the toggle after two seconds so it will display correctly

• • Make sure that you have sound coming into the computer, then click on the toggle to record two
seconds of the incoming sound. If you want to, you can double-click on the buffer~ afterward to see
the recorded signal.

Reading through a buffer~: index~

So far you have seen two ways to get sound into a buffer~. You can read in an existing audio file with
the read message, and you can record sound into it with the record~ object. Once you get the sound
into a buffer~, there are several things you can do with it. You can save it to an audio file by sending
the write message to the buffer~. You can use 513 samples of it as a wavetable for cycle~, as
demonstrated in Tutorial 3. You can use any section of it as a transfer function for lookup~, as
demonstrated in Tutorial 14.

The index~ object receives a signal as its input, which represents a sample number. It looks up that
sample in its associated buffer~, and sends the value of that sample out its outlet as a signal. The
count~ object just sends out a signal value that increases by one with each sample. So, if you send the
output of count~ -- a steady stream of increasing numbers -- to the input of index~ -- which will
treat them as sample numbers -- index~ will read straight through the buffer~, playing it back at the
current sampling rate.

file:///C:/Program%20Files/Cycling%20'74/Max%205.0/patches/docs/tutorials/msp-tu... 21/09/2017
MSP Tutorial 13: Recording and Playback Página 3 de 4

Play the sound in a buffer~ by looking up each sample and sending it to the dac~

• • Click on the button marked ‘Play’ to play the sound in the buffer~. You can change the starting
sample number by sending a different starting number into count~.

This combination of count~ and index~ lets you specify a precise sample number in the buffer~
where you want to start playback. However, if you want to specify starting and ending points in the
buffer~ in terms of milliseconds, and/or you want to play the sound back at a different speed -- or
even backward -- then the play~ object is more appropriate.

Variable speed playback: play~

The play~ object receives a signal in its inlet which indicates a position, in milliseconds, in its
associated buffer~; play~ sends out the signal value it finds at that point in the buffer~. Unlike
index~, though, when play~ receives a position that falls between two samples in the buffer~ it
interpolates between those two values. For this reason, you can read through a buffer~ at any speed
by sending an increasing or decreasing signal to play~, and it will interpolate between samples as
necessary. (Theoretically, you could use index~ in a similar manner, but it does not interpolate
between samples so the sound fidelity would be considerably worse.)

The most obvious way to use the play~ object is to send it a linearly increasing (or decreasing) signal
from a line~ object, as shown in the tutorial patch.

Read through a buffer~, from one position to another, in a given amount of time

Reading from 0 to 2000 (millisecond position in the buffer~) in a time of 2000 ms produces normal
playback. Reading from 0 to 2000 in 4000 ms produces half-speed playback, and so on.

• • Click on the different message box objects to hear the sound played in various speed/direction
combinations. Turn audio off when you have finished.
Although not demonstrated in this tutorial patch, it's worth noting that you could use other signals as
input to play~ in order to achieve accelerations and decelerations, such as an exponential curve from

file:///C:/Program%20Files/Cycling%20'74/Max%205.0/patches/docs/tutorials/msp-tu... 21/09/2017
MSP Tutorial 13: Recording and Playback Página 4 de 4

a curve~ object or even an appropriately scaled sinusoid from a cycle~ object.

Summary
Sound coming into the computer enters MSP via the adc~ object. The record~ object stores the
incoming sound -- or any other signal -- in a buffer~. You can record into the entire buffer~, or you
can record into any portion of it by specifying start and end buffer positions in the two rightmost
inlets of record~. For simple normal-speed playback of the sound in a buffer~, you can use the
count~ and index~ objects to read through it at the current sampling rate. Use the line~ and play~
objects for variable-speed playback and/or for reading through the buffer~ in both directions.

See Also
Name Description
adc~ Audio input and on/off
ezadc~ Audio input and on/off button
index~ Sample playback without interpolation
play~ Position-based sample playback
record~ Record sound into a buffer

file:///C:/Program%20Files/Cycling%20'74/Max%205.0/patches/docs/tutorials/msp-tu... 21/09/2017