1a.jan7.mp4
00:00 Intro and mechanics of course
18:40 Getting Pure Data (Pd) and running it
30:36 Configuring and testing audio in and out
47:45 Editing patches in Pd
1:04:00 Organizing files so that Pd finds the out1~ helper object
1:09:30 The scope~ helper object

1b.jan9.mp4
0:00 downloading patches from browsers (patches look like text files)
5:00 Audio signals and control messages (types of connection)
6:00 Boxes: objects, messages, numbers
12:00 more on audio signals and control messages
15:41 Scope~ object to see oscillator output.  Setting frequency of oscillator
24:00 Making a complex tone with three oscillators
27:00 Tilde convention.  Multiplier (*~) as amplitude controller
35:00 Using a number box to display/change numbers
48:30 Using line~ to make continuous changes of amplitude
57:00 Messages with two numbers and "$1" convention for making variable messages
1:01:15 Messages into signal inputs and vice versa 
1:02:00 peek~ helper object to look at line~ output
1:04:00 explanation of button and toggle on scope~ interface
1:05:00 Connecting to multiple messages to set them off simultaneously
1:15:00 Osc1~ creation argument versus sending it messages
1:15:45 Osc1~ first input takes signals.  Osc1~ help window
1:19:00 Details about homework 1

2a.jan14.mp4
0:00 Wavetables (arrays of numbers)
2:35 New objects used this week
5:30 Definition of phase (with sinusoid as example)
9:30 Phasors and wavetables as components of a digital oscillator
11:30 cosine wavetable and interpolation in table lookup
22:10 Changing the range of a numerical control or signal value
24:00 Using phasor~, array, and tabread~ to make a variable-waveform oscillator
35:50 Two wavetable oscillators with slight detuning
43:50 Intro to homework 2 (array to control pitch sequence)
46:50 Web page to get patches and th flute soundfile used in homework
51:00 Creating more than one phase signal with a controllable phase difference
1:05:50 using adc~ to record sound into an array and tabread to "sample" it
1:11:20 Setting the range of lookup into an array holding a recorded sound
1:15:30 Writing and reading arrays to soundfiles using soundfiler object

2b.jan16.mp4
0:00 Interpolating and non-interpolating table lookup
5:00 Setting an array to hold a cosine cycle using "cosinesum" message to array
5:30 The send object (used to send a message to an array)
10:26 Non-interpolating lookup and how it sounds as a waveform
16:10 tabread4~ and interpolating table lookup
20:00 Cubic (4-point) interpolation explained.  N-3 available points in table
29:00 Setting range of phasor~ to (1-9) to fit into 11-point table
42:30 interpolating and non-interpolating into an audio recording
52:00 Range of phasor~ for reading into audio recording
1:02:00 De-clicking a looped read from a recording using a half-cosine envelope
1:09:30 Overlapped playback from a recording to make a more continuous sound

3a.jan21.mp4
0:00 overall topic: control and audio distinction in more detail
1:40 make a table-reading sound to control
2:10 problem to watch for: multiply defined arrays
3:40 another possible problem: signal (DSP) loops
7:00 patches on website are now zipped
8:00 introducing homework 3
11:30 control version of table read (tableread instead of tabread~)
13:40 "mod" object (modular arithmetic)  for wraparound control table lookup
14:30 comparing wraparound lookup using phasor~ (DSP correlate of above)
20:50 the "metro" obejct (metronome)
23:00 toggle and bang objects (GUI controls)
28:30 the "float" object for number storage
29:30 hot and cold inlets (left-most inlets cause actions; others modify them)
33:50 making a control-object loop (a 0-to-11 counter)
40:00 another possible problem: infinite loops of control messages
48:00 how to make presets using send and receive
57:30 semicolon-separated messages in message boxes (sending to receive objects)
1:06:30 the "mtof" object, MIDI pitches and frequencies
1:10:00 speak preview of spectrum object to see effect of frequency ratios
1:19:45 C major chord, as MIDI pitches and ratios

3b.jan23.mp4
0:00 introducing this table of contents
1:00 starting from patch from Jan 16, to work on amplitude and pitch control
5:00 showing the enveloped waveform and a simple timbre control
10:00 notes versus sounds as musical building blocks
12:00 problem with using "line" directly as an amplitude control
13:00 "delay" object to sequence line~ level changes to form notes
13:40 the bad fade-out behavior line~ gives over 10 seconds.
16:00 square root of amplitude as approximate loudness
19:00 squaring line~ output for a better amplitude ramp
22:22 introducing MIDI keyboard control
33:00 MIDI and musical intervals
39:00 why 3.86 MIDI units makes a major third (5:4 ratio)
43:00 transposing MIDI
44:00 making MIDI keyboard set off notes by triggering amplitude change
52:00 making the timbre change over the duration of a note
59:00 review of the half-cosine envelope control for the table waveform
1:04:30 printing messages that go to line~ to control it over time
1:06:00 "$1" inside message boxes to make variable messages
1:09:00 metronome-driven counter to "route" object to make rhythms
1:15:30 miscellaneous questions and answers


4a.jan28.mp4
0:00 intro to topic, voice management and polyphony using subpatches
1:00 subpatches
3:00 inlets and outlets for subpatches
5:15 abstractions versus one-off (ad hoc) subpatches
7:30 warning, don't send a 'float' to delay unless you want to set delay time
10:00 moving a sinusoid oscillator patch into another patch as an abstraction
12:40 saving an abstraction from inside the calling patch
14:00 inlets adn outlets in abstractions
18:20 commas inside message boxes send multiple messages
23:00 counter and route to distribute notes across copies of an abstraction
26:45 the pack object
28:30 the trigger object
38:00 Risset's bell instrument using an abstraction for each sinusoidal partial
41:00 throw~ and catch~ (preview)
44:00 how messages get into the partials in the bell patch
46:00 arguments to abstractions ("$" arguments in object boxes versus messages)
1:07:00 using "moses" object to split pitches among two different voice banks
1:10:00 making a sample-looping abstraction
1:13:00 building the second voice bank
1:16:00 the moses object

4b.jan30.mp4
0:00 incitement: running a patch inside an Organelle keyboard instrument
6:00 rewriting sampler abstraction to play notes using the sample's own attack
11:30 getting the size of a soundfile in samples
16:30 right inlet of phasor~ to reset the phase using a message
19:00 control computations insert themselves between audio sample computations
19:45 when you save an abstraction all the other copies might need reinitialization
22:00 looping samplers at different speeds
24:00 computing the length of a recording if it's transposed
25:00 using trigger to get a division to work when divisor changes
27:00 using float object to use a value after a delay
28:00 working piano sampler
30:00 using the two different timbres for a rhythmic effect
35:00 the "clone" object to manage copies of an abstraction
40:00 using an abstraction to reuse a patch from different calling patches
47:00 introducing homework assignment 4
50:00 "const" message to an array to clear it
55:00 sending a message to an array to set its values
56:30 about final project
1:00:30 idea: Hammond organ patch with added amplitude envelope control
1:02:00 better way to use "send"/"receive" technique for managing controls
1:05:00 "set" message to number box
1:06:00 setting send and receive names for number box
1:08:00 adding a label to the number box
1:09:00 an abstraction (setctl) for controlling a parameter and displaying it

5a.feb4.mp4
0:00 incitement: the Gem graphics environment for Pd
3:50 envelope following to use incoming sound level as a control
5:00 decibel units and attack detection (mentioned but not described fully)
6:00 drawing polygons in Gem
8:00 3-d coordinates in Gem
11:00 changing coordinates under programmatic control (by sending messages)
15:00 "rectangle" abstraction to draw a rectangle using arrays for coordinates
20:20 homework 5 intro
26:00 frequency modulation using two oscillators
31:20 spectrum of FM output (using spectrum~ helper object)
40:00 carrier frequency, modulation frequency, and index parameters
42:00 making harmonic spectra using FM
38:30 reflections and negative frequency sidebands in FM
44:30 ring modulation
50:00 ring modulating a complex spectrum
53:00 the fundamental formula for computer music (multiplying sinusoids)
58:00 using the formula to understand the sidebands from amplitude modulation
1:03 ring modulate an incoming sound from a microphone
1:09:00 nonlinear distortion (waveshaping)
1:12:00 squaring a sinusoid doubles its frequency
1:13:00 using an array as a waveshaping function
1:16 clipping (saturation) - crude example using hand-drawn wavetable
1:16:30 changing amplitude of input to waveshaping changes timbre

5b.feb6.mp4
0:00 more details on homework 4
4:00 using $ arguments inside abstraction as an index in an array
6:00 banging a float $1 object inside an abstraction
11:00 numbers to first inlet of float
13:00 commas versus semicolons in message boxes
15:00 incitement: the phase vocoder (I07.phase.vocoder.pd in the Pd examples)
24:30 intro to homework 5
28:00 messages to line~ that's already ramping interrupts ramp to start new one
33:30 symmetry in waveshaping (even and odd harmonics)
37:00 clipping using "min~" and "max~" objects
41:20 other shapes in the waveshaping array
43:00 waveshaping versus sampling as a waveform generator
46:00 adding an offset (a "bias") to teh input to waveshaping
48:00 continuously drifting bias to get a time-varying timbre
52:00 symmetry.  Change the wavetable to a pre-prepared one (cos~ object)
57:00 evenness and oddness of functions and their use in waveshaping
59:00 odd function as waveshaper
1:02:00 using cos~ waveshaper to generate even harmonics
1:03 changing bias to get sine function from cos~ object
1:07: cosine function periodicity and bias
1:09:20 digression: the "random" object used on pitch and waveshaping index

6a.feb11.mp4
0:00 incitement: sample-and-hold.  First introduce noise~ object
7:30 random versus noise~
9:00 audio decimation
14:00 one sawtooth (phasor~) sample-and-holding another
22:35 introducing "array" object (non-graphical array storage)
26:30 introducing homework 6
29:00 introducing delays using delwrite~ and delread~ objects
37:00 multiple delay taps from a single delay line
39:30 frequency response of a single delay added to a signal
44:00 phase cancellation using delays
46:00 spectrum of combined signal adn delayed copy (comb filter)
53:00 feedback with delays
1:00:00 delay loop making a tone
1:03:00 feedback gain control
1:08:00 controlling amplitude of direct signal and delays with feedback
1:10:00 changing delay times without clicks by muting output at moment of change
1:15:30 continuously changing delay time using delread4~
1:18:00 Doppler effect from changing delay time

6b.feb13.mp4
0:00 more on shifting pitch using delread4~
1:30 homework 6
4:30 making pitches using recirculating (feedback) delay as comb filter
7:00 pulsed noise for testing comb filter
8:30 pitch of output of comb filter
10:00 spectrum of feedback comb filter output
13:30 effect of integer-sample-delay restriction of delread~ (vs. delread4~)
17:00 reverberation ("reverb")
23:00 comb filter abstraction 
24:00 Pd warned before retyping into an abstraction that's been edited
29:00 oops, delread4~ doesn't take an argument to set delay time
33:00 oops, rogue out1~ object
34:00 working reverberator
37:30 pitch shifter
41:50 phasor~ driving delread4~ to make doppler shift
44:45 adc~ into rudimentary pitch shifter to show window size limitation
46:20 windowing output of delay to stop clicks in pitch shifter
48:30 cos~ object from -1/4 to 1/4 makes a good window shape
49:00 windowed pitch shifter (no overlap yet)
50:00 adding out-of-phase copy for overlapping windows
53:00 computing pitch shift from window size and phasor frequency
58:00 slope of phasor~ output
1:02:00 figuring out phasor frequency for desired transposition: f = (t - 1)/w
1:05:00 desired pitch shift in half steps (MIDI units)
1:10:00 chorus effect (mentioned, not done)
1:12:00 more about randomness (random numbers with controllable probabilities

7a.feb18.mp4
0:00 incitement 1 - beat boxer
4:00 bonk~ attack detector object
6:20 incitement 2 - visualizing data structures in Pd
12:40 homework 6 intro
14:40 followup about sampling (making notes that come out at correct pitch)
16:30 the tabplay~ object
17:00 revisiting the 4.b.sampler.pd abstraction to get correct pitch out
20:00 making new version, 7.a.sampler-voice.pd
21:00 writing sample length to sampler-nsamps that is read inside abstraction
23:00 computing the frequency a phasor~ should run at to get desired pitch
30:20 finished sampler abstraction
35:00 how filters work: comb filters and pitch revisited
40:00 the block~ object to set block size in a subpatch to make a low-pass filter
45:00 how to get unit gain at DC in a low-pass filter (moving averages)
51:03 making a high-pass filter out of the low-pass filter
54:30 the lop~ and hip~ low and high pass filters
57:00 the bp~ (briefly) and vcf~ filters
59:00 the "Q" inlet of vcf~
1:06:00 making a pulse as a test input to vcf~
1:07:00 phasor~ into pulse table to make a pulse train
1:09:00 changing pulse width changes spectrum
1:11:00 resonant filter acting on a pulse train
1:12:00 high values of Q single out harmonics; low ones give timbre changes
1:13:00 getting rid of zipper noise when sweeping resonant frequency of vcf~
1:14:00 envelope generator driving resonant frequency
1:15:00 classic note-based subtractive synthesis
1:17:30 changing pulse width of input to vcf~

7b.feb20.mp4
0:00 incitement: high-Q resonant filters for resonating ambient sounds
4:30 intro to homework 7: Devid Wessel streaming demonstration
13:00 back to subtractive synthesis
18:30 adjusting gain of vcf~ to adjust for variable Q
20:00 higher Q values make longer-lasting resonances
22:00 Q as number of wiggles in the impulse response independent of frequency
25:00 taxonomy of filters (definitions of cutoff/rolloff frequency, etc)
28:00 passband, stop band, and transition region
30:00 resonant frequency and bandwidth of a resonant filter
32:00 definition of Q
34:00 Q=17 is about a half-step wide
37:00 mass-and-spring physical analogy
40:00 how to make a resonant filter using rotations in the plane
42:00 using complex numbers to represent rotations
45:00 1, A, A^2, ... sequence is a sinusoid if A is a unit complex number
45:30 how to analyze the behavior of a recirculating delay network
48:00 impulse response of a recirculating delay network
54:00 complex sinusoid again (using Z as the ratio: ..., Z^-1, 1, Z, Z^2, ...)
56:00 analysing frequency response of recirculating delay network
1:01:00 setting up equation relating output to input
1:02:00 geometrical interpretation of frequency response
1:05:00 how resonant frequency and bandwidth depend on recirculation gain
1:08:00 "hilbert~" filter to get phase-quadrature version of a real sinusoid
1:12:00 single-sideband modulation
1:15:00 the phaser (guitar effect)

8a.feb25.mp4
0:00 about homework 7: text object will help (but isn't altogether needed)
2:00 a musical sequence as a text file
4:45 "text" object
6:00 text object subwindow is formatted like message boxes
7:00 "text" object help window.  "text define" makes and names a text object
8:00 "text define -k" to keep the text between Pd sessions
8:45 "text get"
9:30 message selectors and list messages (needs "list" if first item is symbol)
11:00 messages starting with numbers are implicitly "list"
12:00 getting single item ("atom") in the list
13:45 "text set" object to replace lines or single items in a "text"
17:00 making a simple sequencer using text object
19:00 variable time delays in sequences.  Line starts with initial delay
21:00 bad way (time value is time to next line) and good way
25:30 "text sequence" for built-in sequencer
28:00 "text sequence poodle -w 1" to make a simple sequencer
29:30 tempo control
31:30 looping sequencer using "text" object
34:00 meaning of "stop" messages to "text sequence", "delay", etc.
36:30 incremental versus accumulated time in sequencer design
39:00 polyphonic sequencing from a text file (Bach invention example)
43:00 making a synthesizer voice with controllable note lengths
46:00 "-c" flag to read text files without semicolons in them
48:00 sequencing ignoring time values
49:00 using "text sequence" to sequence the Bach example with correct times
51:00 voices and voice allocation using the "poly" object
58:00 "makenote" object to schedule note-offs after specified delays
1:02:00 new version of 8.b.voice.pd so that it takes note-on/note-off messages
1:09:00 possible variations in message style inside text sequences
1:11:30 a sequence from a real piece of music containing arbitrary messages

8b.feb27.mp4
0:00 incitement: leap controller as musical instrument controller
0:45 imaginary pool table as oscillator pair
3:30 eight parameters to control the pool-table oscillator
4:00 8 parameters derived from hand shape detected by controller
8:00 sensible controller design principle: easy on/off and loudness control
12:30 reverberation from spatial location and loudness from angle
16:00 intro to homework 8
26:00 2 miscellaneous things about filters: filtering a sinusoid does little.
28:00 low-pass filter to solve click problems
31:00 low-pass filter is smoothing in time
35:00 designing timed loops that stop at specified point
38:30 using delays to control order of execution is hard to extend or debug
39:00 loops with no internal delays using "until" object
43:00 incidentally, there's a "bang" object, does same thing as "t b"
44:00 "forloop" abstraction
48:00 you can just send a number to "until" to get that number of bangs
49:00 using loops to evaluate formulas to load into an array
49:30 example: Cauchy distribution: 1/(1+x*x)
52:00 center the curve at 51 for a 103-point table (for use with tabread4~)
56:00 Gaussian curve
58:00 "expr" object to simplify trigger-driven horrorshows to do algebra
1:02:00 the "env~" and "sigmund~" objects to estimate signal power and pitch
1:03:00 the decibel (dB)  scale (output from env~)
1:04:00 the VU meter
1:04:30 the "dbtorms" object converts decibels to linear amplitude
1:07:00 envelope-controlled oscillator
1:08:00 env~ output at 44100 Hz. appears every 512 samples (11.62 milliseconds)
1:09:00 sigmund~ pitch tracker (and more)
1:12:00 voice-controlled oscillator (pitch and amplitude)
1:13:00 quantizing (rounding pitch off to nearest integer)
1:15:00 starting on presets (wil finish in 9a video)
1:17:30 "presetter" abstraction will be setctl plus preset saver
1:19:00 printing out the name of the preset variable using "symbol" object

9a.mar3.mp4
0:30 finishing the presetter abstraction
2:00 pack and unpack with symbols
4:30 message selectors (automatic only if list starts with a number)
5:00 "bang", "float", "symbol" and "list" selectors
7:30 printing parameter messages returned from presetter
8:00 collecting them in a "text" object ("text set" to append lines)
11:00 clearing the text object out before parameters are put in using trigger
16:00 incitement: waveshaping (distorting) combined sounds of different periods
19:00 clip~ as waveshaper
20:00 designing smooth waveshaping functions
22:00 y = x - x^3/3 cubic curve as waveshaper
27:00 cubic waveshaper without clipping
29:30 clipping the input to the cubic
32:00 sum of 440- and 660-hz sinusoids into waveshaper gives common subharmonic
36:30 oops, we were listening to the wrong signal before - fixed now
40:30 another incitement: deliberate unstable feedback through a delay line
42:30 test signal into a pitch shifter
44:30 soft-clipping the output of the pitch shifter and feeding it back
49:00 feedback dies if it's pitch shifted out of range
50:00 restricting the frequency range of feedback with hip~ and lop~ filters
54:00 changing the pitch-shift delay time and frequency range
1:00:45 incitement: measuring tempo using "bonk~" and "timer" objects
1:05:00 trigger to control two "bang" messages to "timer"
1:06:00 using that to drive a "metro" object
1:07:00 controling a test beep from the result
1:08:00 triggering sample recording from bonk~ and playback from metro objects
1:12:00 foldover (intro for weeks' topic, band-limited waveforms)

9b.mar5.mp4
0:00 incitement: partial tracer (Pd audio example)
11:00 sinebag example - real-time additive analysis/resynthesis using sigmund~
14:00 back to foldover issue.  Pd audio example demonstrating foldover
18:00 making a band-limited sawtooth wave
23:00 approximating a sawtooth summing sinusoids
28:00 square wave as sum of sinusoids
31:30 using the square wave as transition for a step in an audio signal
34:00 oscillator repeating the step
35:00 changing the duration of the ripple portion of the step
37:00 subtracting the original phasor~ to get rid of the discontinuity
39:00 changing the band limit on a sawtooth wave
40:00 comparing the three sawtooth generators (phasor~, fixed partial sum, and new version)
42:00 spectrum of band-limited sawtooth
45:30 making a rectangle wave out of two sawtooth waves
48:00 why subtracting two sawtooth waves gives a rectangle wave
50:00 spectrum of rectangle wave
54:00 triangle waves out of phasor~
57:00 spectrum of symmetric triangle wave
1:00:30 non-symmetric triangle
1:04:00 triangles as difference between two parabolic waves
1:06:30 spectrum of parabolic wave
1:08:00 parabolic waves subtracted
1:08:30 trapezoidal wave: sum of parabolic waves with gains that sum to zero

10a.mar10.mp4
0:00 prep for final - making screen movies (I use ffmpeg; OBS easier to use)
5:30 how to turn in final projects
8:20 incitement: video feedback using Gem
10:30 making ribbons using hundreds of triangles
11:00 looking up colors and coordinates from tables (arrays)
11:30 making the snake slither by sliding forward in the arrays
13:30 making video feedback in Gem: pix_snap2tex object
15:30 reducing size and orientation of fed-back copy
17:30 adding a second feedback path
19:20 topic: frequency domain processing using example from Pd doc
20:10 The J series of Pd audio examples are on previous class's topic
21:00 The I series, recalling the phase vocoder incitement from earlier
21:30 Motivation: Problems with time streching via granular sampling
23:00 Problem of overlapping audio recordings without phase cancellation
24:30 idea of Fourier analysis/synthesis.  Path I01.Fourier.analysis.pd
28:30 Fourier analysis period N controlled by block size in Pd
30:30 typical block sizes are 512-4096 but first example uses 64 samples
34:00 phase of test oscillator is reset each window
36:00 different initial phases to input of Forier analysis
36:30 explanation of fft~ output as real and imaginary parts of analysis
37:10 64th point of output is same as zeroth point
38:00 complex exponentials as true basis functions (instead of sine/cosine)
40:20 cos(phase) + i sin(phase).  Phase is 2 pi n / N for fundamental
41:00 negative frequencies. Real-valued cosine is sum of two complex exponentials
43:00 complex sinusoids are eigenvectors of time
45:00 complex multiplication used to knock frequemcy down to zero for analysis
47:00 how initial phase of real sinusoid changes fft~ output
49:00 real and imaginary part of tenth fft~ analysis graphed in complex plane
51:00 analyzing sinusoid with frequency 10.5 (between harmonics)
54:30 partials drop off as 1/k from peak
56:00 using a raised cosine window as (Hann) windowing function
57:00 using windowing function helps resolve sinusoidal components
58:00 example I02: applying Hann window function
59:00 the tabreceive~ object.  Setting window size to 512 via block~ object
1:00:00 the rfft~ object and taking magnitude
1:01:00 changing window function.  Heisenberg uncertainty principle.
1:05:00 filtering using Fourier analysis/resynthesis
1:07:00 overlapping windows 
1:09:00 applying windowing function both before and after analysis/resynthesis
1:11:00 analysis/resynthesis patch with blocking, windowing, and normalization
1:14:00 fft vocoder, patch I06.timbre.stamp.pd
1:17:00 changing pitch of voice
1:18:00 how the patch works

10b.mar12.mp4
0:00 incitement: drum machine using PAF (fancy waveshaping) synthesis
3:00 audio production techniques
4:00 dynamics processing: companding compression and expansion) and limiting
15:00 filtering, DJ-style, using high-order (Butterworth) filters
16:30 returning to Fourier analysis/resynthesis
18:00 analysis/resynthesis considered as filterbank
20:00 arranging phase coherency in each channel in resynthesis
25:00 quick tour of I07.phase.vocoder.pd patch
26:30 topic: panning and cross-fading
29:30 what gain should we use half-way across a pan or cross-fade? 1/2 or 1/sqrt(2)?
32:40 How pan should depend on left/right control (not linearly)
36:00 quadraphonic speaker setups for 1950s - 1970s style spatialization
42:00 readsf~ and writesf~ to stream from and to soundfile in real time
48:00 sending messages over networks
50:30 messages between Pd and other programs: pdsend and pdreceive
57:45 conditionals in Pd: route, moses, spigot
1:00:00 reminder, execution order
1:01:00 control messages from signals: env~, snapshot~, threshold~
1:05:00 state machine to detect audio onsets