Music Technology / Interactive Arts Programming

Winter 2012

Assignments for the upcoming class session are posted below.

For Thursday March 22:

Be prepared to give a polished presentation of your final project by presenting/performing it for the class and briefly explaining how the underlying software works.

Deposit your completed project, including any necessary audio/video files, in the EEE DropBox called "08-FinalProject". Include as much commentary and explanatory text as you think is needed for someone to understand exactly how your program works and evaluate its correctness.

For Thursday March 15:

Come to class prepared to ask whatever questions you need answered to help you complete your final project successfully.

For Tuesday March 13:

Study these examples on audio patch management.
2010 Example 22: Switching and mixing audio processes
2011 Example 19: Mixing multiple audio processes

Study these articles and examples on audio filtering.
2010 Example 19: Bandpass filter swept with a LFO
2010 Example 20: A variable-mode filter: biquad~
2010 Example 21: Smooth filter changes
MSP Tutorial 31: Comb filter

For Thursday March 8:

Develop at least one small aspect of your final project into a working program that performs a task correctly and reliably. The idea is to get started in your larger project by identifying one small component of the larger problem and solving that one part of the problem. The result will likely be an abstraction (a working patch with inlets and outlets) that can be used as a reliable subpatch in a larger program. Put sufficient commentary in your patch so that anyone could open it and know what it is intended to do, what its input and output are, and how it works. Of course, if you achieve more than one such patch, so much the better. Deposit your program(s) in the EEE DropBox called "07-1stSteps" by 12:00 noon on Thursday March 8.

For Tuesday March 6:

By midnight on the evening of Sunday March 4, post on the MessageBoard a proposal for your final project. By 10:00 pm on the evening of Monday March 5, post a (hopefully helpful) comment on at least one classmate's proposal.

Study as many as possible of these chapters (and the example Max patches) in the Algorithmic Composition blog regarding the musical use of randomness.
Randomness and noise
A simple probabilistic decision
Probability distribution
Limiting the range of random choices
Moving range of random choices

Here are some examples from previous classes demonstrating a few uses of randomness.
2010 Example 7: Random number generators: random and urn
2011 Example 12: Random note choices
2010 Example 17: Pass a certain percentage of bangs
2010 Example 8: Random video editing
2010 Example 49: Play random clips (in reverse) from a RAM buffer
2009 Example 13: Delaying numbers by a random amount of time to create irregular timing
2009 Example 14: Random transposition of notes
2007 Example 3: Minimal loops, using a portion of a table (scroll down to Example 3)

For Thursday March 1:

Based on the instructions for the final project, give some thought to what you'd like to do for your own project, and come to class ready to discuss it. We'll discuss possible projects in Thursday's class, and I'll ask you to put a written proposal on the MessageBoard by the end of this weekend.

Study as many of the following examples of audio delay as possible, so that you feel you fully understand how to delay sound in MSP, how to get delay with feedback, how to change delay time without clicks, and how to use continually changing delay times to achieve effects such as flanging and chorusing.
Example 27: Simple delay of audio signal
Example 28: Delay with tempo-relative timing
Example 29: Ducking when changing delay time
Example 30: Simple flanging
Example 31: Delay with feedback
2009 Example 33: Delay-based effects
2009 Example 34: Crossfading between two different delay times
2010 Example 35: Multi-tap audio delay with feedback
2010 Example 36: Flanging
2010 Example 37: Chorusing
2011 Example 21: Rhythmic delays in time with a musical tempo
MSP Tutorial 27: Delay lines
MSP Tutorial 28: Delay lines with feedback

For Tuesday February 28:

Make a program that uses sampled sound in a buffer~ (either live-recorded or pre-recorded) to produce a novel sound, an interesting rhythmic pattern of sound, or a collage of sound segments. At the minimum your result should be a novel and interesting sound; for a more fully developed result you can combine different samples and/or processes to create something more akin to a short musical composition. You can access the contents of the buffer~ with any of the available buffer-related objects such as index~, play~, groove~, wave~, cycle~, etc. You can shape the amplitude of the sound with line~, trapezoid~, phasor~, etc. controlling a *~ object. For musically useful rhythmic sounds, you might also want to consider using transport-related timing.

Include many (an overabundance of) comments in your program to explain what you've done and to demonstrate that you understand fully how it works. Place your completed assignment, and any necessary sound files, in the EEE DropBox called "06-BufferAccess" by 7:00 pm on Monday February 27.

As every week, by midnight on the evening of Sunday February 26, post on the MessageBoard at least one useful thing you learned about Max programming this week from your own experimentation and study. (The more the better.)

For Thursday February 23:

Study MSP Tutorials 13 and 14 regarding the use of sound samples stored in a RAM buffer, and try out the tutorial patches for those chapters. Once you feel comfortable with the way the buffer~, record~, play~, and groove~ objects work, try to solve the programming problem posed in MSP Tutorial 17. If you get stumped, you can consult the solution provided at the end of the tutorial chapter, but try to solve it on your own first. Then see if you can devise your own interesting application of buffer~ and its related access objects such as cycle~, record~, play~, groove~, etc.. You don't need to hand your work in, but the time you spend experimenting will be helpful in the learning process.

For Tuesday February 21:

We perceive change in musical attributes such as pitch and loudness more-or-less proportionally to the logarithm of their subjective empirical attributes of frequency and amplitude. We hear change in tempo in terms of events per unit of time (rate) more than as a difference in absolute time (interval). In all these cases, we care more about the ratio (division) between two frequencies/amplitudes/intervals than the arithmetic difference (subtraction) between them. This is important to understand in order to program the desired sonic/musical results.

Read (and download the Max patches and try them out!) these examples from past classes regarding the subject of linear vs. exponential change.
- 2009 Example 36: Linear vs. exponential change in frequency and amplitude.
- 2009 Example 37: Linear vs. exponential change in the rate of events.
- 2011 Example 13: Audio amplitude control.
- 2010 Example 10: Exponential mapping.
- 2009 Example 17: Flanging a sound file by modulating the playback rate.

For Thursday February 16:

There will be no class meeting at the regular time. Instead, you should attend the lecture on "Gestural Sound" at 4:30 pm in Winifred Smith Hall, and the Gassmann Electronic Music Series concert "Computer-Mediated" at 8:00 pm in Winifred Smith Hall. Both events are free.

For Tuesday February 14:

With your group members, give a 10-minute presentation of your midterm group project, displaying its capabilities and explaining its operation. You will need to be well prepared to use your time effectively. Plan what equipment, if any, you will need to set up, plan what you will do and say, and try it out (yes, rehearse) to make sure it's feasible in the allotted time.

One member of each group should deposit the entire project in her/his folder of the DropBox called "05-MidtermProject". Each of the group members should deposit, in her/his own folder of the DropBox, a text document (.txt, .rtf, or .doc) describing what portion of the group project was primarily their own contribution. You're also welcome to mention ideas you have for improvement or further development.

For Thursday February 9:

Study MSP Tutorial 8: Tremolo and Ring Modulation, MSP Tutorial 9: Amplitude Modulation, and MSP Tutorial 10: Vibrato and FM. Play around with the number boxes in those tutorial patches till you have a good understanding of what happens sonically when you change the different parameters (especially the rate and depth of the modulation). Also, take a look at Example 15: Amplitude modulation and frequency modulation from last year's class, download the patch and play around with the controls in that patch.

If that's all pretty simple and easy to understand, and/or you're a glutton for audio processing knowledge, go on and read MSP Tutorial 11: Frequency Modulation. That example patch uses an object you may not have seen yet, called "function", that allows you to draw a line-segment control function. It's explained in MSP Tutorial 7, and of course also in the function object manual page and help file.

And if you want to read about the compositional use of classic waveforms (sine, sawtooth, square, and triangle waves) as control functions, you can read these articles from the Algorithmic Composition blog:
Classic waveforms as control functions
Sine wave as control function
Pulse wave, a binary control function
Triangle wave as a control function

For Tuesday February 7:

Read the article on the Algorithmic Composition blog titled "Tempo-relative timing". Read the articles in the Max documentation about Specifying Time Values, especially the articles regarding Time Value Syntax and Objects that Support Time Values. There are several examples online of how to implement tempo-relative timing in Max. Study Examples 42 through 48 from the 2010 IAP class. Think about how tempo-relative timing might be useful in your own projects. To test your understanding of the transport in Max, write a simple program that performs some timed action that is synchronized to the transport's beat clock.

Deposit your completed assignment, with any necessary accompanying files, in the EEE DropBox called "04-Transport" no later than 7:00 pm on Monday February 6.

As every week, by midnight on the evening of Sunday February 5, post on the MessageBoard at least one useful thing you learned about Max programming this week from your own independent study and practice. (The more the better.) It need not be of earthshaking novelty or significance, but it should be something more than simply asking a question or namedropping an object. Try to give enough information as to be instructive and helpful to others.

For Thursday February 2:

These assigned readings are to reinforce and elaborate two topics discussed briefly in last week's class. One is "Encapsulation": constructing a program from individual modules, each of which performs a specific task that is part of a larger structure. You can write a very small simple program, test it to be sure it works, then use it reliably inside other programs. Another topic is changeable "Arguments": $1 $2 etc. in a message box and #1 #2 etc. in an abstraction (a patch that you design and save for use as an object in a parent patch).

Don't worry if you don't understand every aspect of these articles, but do your best, and come to class with questions.

Start by reading the article on Encapsulation (.pdf) extracted from the Max 4 manual. (The objects in the graphic examples in the article will look strange, because Max 4 had a very different look, but the examples are still valid.)

Then read the page on Creating Subpatchers in the Max 6 documentation.

Next, open and study the help file for the patcher object: Applications/Max6/Cycling '74/max-help/patcher.maxhelp.

Next, read the page on Abstractions in the Max 6 documentation.

Next, open and study the help file for the inlet object -- Applications/Max6/Cycling '74/max-help/inlet.maxhelp -- and the outlet object -- Applications/Max6/Cycling '74/max-help/outlet.maxhelp.

Then read the article on Arguments (.pdf) extracted from the Max 4 manual.

Then open and study the help file for the patcherargs object -- Applications/Max6/Cycling '74/max-help/patcherargs.maxhelp.

Finally, take a look at the example abstraction called lmap, and notice how it uses inlet, outlet, and patcherargs.

For Tuesday January 31:

By midnight on the evening of Sunday January 29, post on the MessageBoard at least one useful thing you learned about Max programming this week from your own independent study and practice. (The more the better.)

Write a program that allows you to "edit" video in real time. Use one or more objects to play the video(s), and send the output to jit.window to view it. To go to a particular spot in a video you can use the 'frame' message or the 'time' message. (To know what frames or times are possible in a video, you will need to use 'getframecount' or 'getduration' messages to query the framecount or duration attribute.) You provide the location you want to go to and play from there. (You're welcome to control other attributes such as rate and vol.)

One way to edit video is called "A-B switching", which involves simply "jump-cutting" from one video clip to another. For A-B switching you need two videos (often referred to as the "A-roll" and the "B-roll", terms coined in filmmaking) so that you can switch suddenly (or crossfade, or perform some other sort of transition) from one to the other. To do that, it's recommended that you have two objects, and send out frames of video from only one of them at a time. To save computation power, it's generally advisable to stop movies that you're not viewing, and only run the video that you are viewing.

Your videos can come from any source, but beware of using videos with vastly differing resolutions or aspect ratios. If you need to, you can use the message 'getmoviedim' to query such the video's dimension attribute, which tells you its resolution, and from which you can calculate its aspect ratio.

Some important attributes and messages for this task will be:

adapt, autostart, dim, duration, framecount, loop, moviedim, rate, time, timescale, unique, vol

bang, frame, jump, loadram, read, start, stop, time

For Thursday January 26:

Read the chapter of the Jitter documentation titled "What is a Matrix?". Read also the chapter discussing "What are Attributes?".

Study the first Jitter Tutorial chapter, titled "Playing A QuickTime Movie" and try the accompanying patch. Study also the 2010 example demonstrating the basics of the object. A look at the help file will show you how very many messages and attributes that object has. Some are arcane and might not be very useful to you, but some are pretty essential, so look at them all and try to get some idea of the possibilities the object makes available to you. Finally, study the manual page for, and in a Max patch of your own try out a few of the messages and attributes you read about. (You don't need to hand in anything; it's just a way to familiarize yourself with the object.)

For Tuesday January 24:

Attend the exhibition "Eyecode: Works by Golan Levin" at the Beall Center for Art and Technology. The Beall Center is open Wednesdays & Sundays from Noon to 5:00 pm, and Thursdays-Saturdays, Noon to 8:00pm. The exhibition ends Sunday January 22.

By midnight on the evening of Sunday January 22, post on the MessageBoard at least one useful thing you learned about Max programming this week from your own independent study and practice. (The more the better.)

In the algorithmic composition blog, read the chapters titled Timed counting, Counting through a List, and Analysis of Some Patterns. (Read other chapters, too, if you're so inspired, of course.)

Write a Max program that plays music with MIDI, using the built-in synthesizer of your computer. (Both QuickTime on Mac OS and DirectX on Windows provide a software MIDI synthesizer as part of the operating system.) You can play notes via the noteout object, you can bend the pitch via the bendout object, you can change the timbre of the sound with the pgmout object, and you can control other aspects of the sound such as volume, panning, and modulation (vibrato) via the ctlout object. Note that you can play different "voices" with different timbral characteristics and different continuous controls by addressing the synthesizer on different MIDI channels.

You can write a program that allows the user to trigger notes via the computer keyboard and/or mouse, but your program should include at least some automated musical behavior using the metro object. The metro might trigger note numbers directly, or might trigger a counter to create a succession of numbers. It could even trigger a random object to generate random musical information, or could read values from a table or a coll (collection). The metro(s) might be set very slow to trigger something periodically, or at a somewhat faster rate to create notes, or at very fast (for example to trigger continuous control messages).

The ultimate goal is to create a program that produces interesting sound and/or music, including some automation, using only the built-in MIDI synthesizer. Deposit your completed project in the EEE DropBox called "02-MIDImusic" no later than 7:00 pm Monday January 23.

Here are a few objects you might want to research and use.

Please deposit your program in the EEE assignment DropBox called "03-VideoEditing" no later than 7:00 pm on Monday January 30. If it's important that I see the same videos as you used, be sure to make a folder and place your program and all your audio files together in that folder to make a complete package. You can compress that folder as a .zip archive to save space and then upload the .zip archive.

For Thursday January 19:

Study "MSP Tutorial 2" regarding linear interpolation for control of audio amplitude. (You can read it online, but to try out the example patch you can also read it by choosing MSP Tutorials from the Help menu in Max, opening MSP Tutorial 2, and clicking on the link there that says "Open the tutorial.") There are several other articles and examples (listed in the next paragraph) that will help you understand linear interpolation, how to control audio amplitude, why and when one should use the decibel scale instead of a straight linear scale, and how the line~ object works. Read as many of these as you can, and as many as you need to in order to have a thorough understanding of how to control audio amplitude in MSP.

Example 4 from last year's class shows the use of the number~ object to smooth out transitions in audio signals. Example 5 from last year shows a very similar technique using the line~ object for fade-in and fade-out. (You can view those two examples in Presentation mode to see an example of a maximally simple interface presented to the user.) You can find still more demonstrations in Example 12 from the 2010 class. For a more in-depth discussion of fading (of both audio and video, but you can ignore the video stuff for now), including some discussion of decibels, see the article on "Fading by means of interpolation" in my algorithmic composition blog. (N.B. That article also uses an object called line, which is similar to line~ but interpolates numbers in Max messages rather than in a MSP signal. You can read more about those two objects in their help files to help you understand their differences.)

In Thursday's class we will discuss the use of MIDI in Max. In preparation for that discussion, read the following two Wikipedia pages about MIDI: MIDI (from the beginning, through the first paragraph of the section on File Formats) and MIDI 1.0 (the section on Message Format), and study the first two Max Tutorials on MIDI: Basics and Note Management.

For Tuesday January 17:

By midnight on the evening of Sunday January 15, post on the MessageBoard at least one useful thing you learned about Max programming this week from your own independent study and practice. (The more the better.) Don't worry about whether the information is sophisticated enough to be useful to others in the class; chances are it will be.

Try to maintain a daily regimen of working through the online Tutorials. (You can access the Tutorials and all the other online documentation via the Help menu in Max.) If you are new to Max, begin with the Max tutorials. Open and try out the Max program associated with each chapter. Once you feel you have the hang of how Max works, and have encountered a modest number of Max objects, you should start reading the MSP tutorials, too. (Continue working on both sets of tutorial lessons in parallel.)

To learn about programming audio in Max, if you have not already done so, read MSP: Introduction, MSP: How Digital Audio Works, and MSP: How MSP Works. Then begin working through the MSP Tutorial chapters.

Try out the Ron Winter drum sampling program. Think about how the program works. Could you make a program in Max that works similarly? Try to build a Max patch that duplicates as much of the capability of that program as possible. Here are some hints of objects that you might need: dac~, sfplay~, key, select, message, fpic (or the Paste Picture command in the Edit menu), ubutton, comment, loadbang. You'll also need some sound files. Download them from the web (e.g. or borrow them from other programs or sources, or record them yourself. You don't need to use the same sounds as are used in the model program; feel free to create your own library of interesting sounds for this purpose. Note that the model program can play polyphonically (i.e., can play multiple simultaneous sounds); that's a moderately complicated thing to program successfully in Max, so don't feel obliged to try to implement that capability (unless, of course, you're an experienced Max programmer and want to take on the challenge). If you think of improvements or elaborations or new ideas to change or extend the program, that's fine, but make a basic imitation of the model program first.

Please deposit your program in the EEE assignment DropBox called "01-PlaySounds" no later than 7:00 pm on Monday January 16. Note that your program won't work as you expect unless it can find the audio files you want to play. So it's best to make a folder and place your program and all your audio files together in that folder to make a complete package. You might want to compress that folder as a .zip archive to save space and then just upload the .zip archive.

For Thursday January 12:

Read Music Programming by Christopher Dobrian.

Make arrangements to come to class with a computer to work on Max. If you can bring your own laptop, download the Max software (which includes some necessary documentation and tutorials) to that computer. If you cannot bring a laptop computer, you can use one of the computers in the REALab during class time, and you can use the computers in the Arts Media Center, the Sound Studio, or the Gassmann Studio for your work outside of class.

If you have not used Max before, begin studying the instructional materials provided in the online documentation of the Max 6 application. Start by watching the Tutorial Zero video, then read at least the first three of the Max 6 Tutorials.

To learn about programming audio in Max, read MSP: How Digital Audio Works, and MSP: How MSP Works. You should read these documents even if you already have experience with Max!

Come to class with questions about the readings! Learning to program in Max is a cumulative educational process, in which each step relies on understandings gained in the previous step, so it's important to ask questions and clarify any ambiguities along the way in order to establish a solid knowledge base.

This page was last modified March 12, 2012.
Christopher Dobrian,