Learn Synthesis with Pure Data Series 02
This series in the overall series, Learn Synthesis with Pure Data, is focused on the more advanced concepts in synthesis. The exploration of the capabilities of Pure Data also go a bit deeper. The first portion of the series focuses on granular synthesis, the second portion on virtual tape loops, the third on ring modulation and delay, and finally the series ends with making a sampler with zones and pitch shifting for sampling instruments for MIDI-triggered playback.
Episode 01 – Making a Looping Sampler for Granular Synthesis
Series 2 of Learn Synthesis with Pure Data begins a new adventure into more advanced forms of synthesis. The first few episodes lead toward exploring granular synthesis and making a granulating synthesizer. This episode begins with making a looping sampler that has pitch/speed control. The purpose is to record samples, load them into an array and then have that array loop playback. Then, we add pitch and speed control such that the loaded sample can be played through faster and slower to create changes in pitch and speed. This basic patch will serve as the foundation for granulating sound which will be covered in the next episode.
Episode 02 – Granulating Sound Part 1
Now that we have created a looping sampler, it is time to turn our attention to granulating the sound. The episode begins with a little bit on using PD patches as abstractions. This is where you can load a Pure Data patch into another one straight from file and allow it to have its own uniqueness within the overall parent patch. After this, we learn how to use sample and hold as a technique for cutting the audio waveform into segments called grains which can then be varied in pitch and speed. This is part 1 of 2 ,and in the next episode we will add windows to smooth out the granulation effect.
Episode 03 – Granulating Sound Part 2 Using a Hanning Window
Our path to granular synthesis has arrived to the point where we can now granulate sound with a Hanning window and thus get a much smoother granulation. In this episode we do review concepts and clean up our patching to make it easier to understand and more organized. Now that we can alter the pitch and speed of playback, the pitch and speed of granulation, and the window size, we can really make some intriguing sounds.
Episode 04 – Finishing Our Granular Synthesizer
In this fourth episode of building a granular synthesizer in Pure Data, we will conclude by making the grain size (window size) and grain speed editable parameters with the use of sliders. In addition to making these functions more convenient to change on the fly, we also add open and save functions so that one can open audio files and save them from within the granular synthesizer.
Episode 05 – Ring Modulation
In this episode, we learn about one of the forms of synthesis that uses waveform distortion to achieve complexity. We look at ring modulation, which is a form of amplitude modulation. When amplitude modulation is lower in frequency than the audible spectrum, it is called tremolo and at slow enough rates can sound pretty cool. When amplitude modulation is taken to faster and faster rates, then it becomes ring modulation with the formation of side bands in the frequency spectrum.
Episode 06 – Making a Sampler Tape Looper
It’s time to look at a different way to make a sampler in Pure Data that can be versatile in synthesis. In this episode, we use a metro object to create a counter that allows audio to play ay multiple speeds and for one to have the audio loop or stop at the end of play. The overall design is like a virtual tape recorder that has rewind and speed control.
Episode 07 – Adding Loop Points to a Sampler
Now that we have a sampler that records, plays, and has pitch controls like a virtual tape looper, it is time to set the start and end points for looping. This allows for one to loop certain regions of the sample that was recorded. This would allow for an attack, a looping audio region for the sustain, and then a release when the sample is to end and play out its decay tail. In this episode, we will see how you can make a sampler mechanism for looping sustain as well as a fun virtual tape looper that allows one to loop different regions on the fly.
Episode 08 – Scrubbing in a Virtual Tape Looper & Debugging Patches
The main mission in this episode is to add a scrubbing feature to the virtual tape looper that we have been making. This allows one to skip around through the audio in real-time. Several techniques and considerations for debugging pd patches are also explored int his episode. Dr. Lawrence W. Moore looks at how number boxes can slow down your patches and how they may best be used in debugging. He needs to utilize his skills in debugging when adding the scrub feature and making sure it works properly with everything else. Pure Data, like any other programming environment can be pretty unforgiving.
Episode 09 – Making a Delay Effect Module
In this series 2 of Learn Synthesis with Pure Data, we have been building modules that can be loaded into Pd as abstractions in parent patches in order to mix and match different modules and create overall modular workspace for creating different sounds. This episode continues in the same line by showing how one can make a delay effect module in Pure Data. The delay effect is a simple effect to make that adds a whole new dynamic to sound.
Episode 10 – Making Input & Output Modules: a Eurorack Like Modular Synth
It’s time to take all of the synthesizer & effect modules that we have been making in this series to the next level by completing the modular system. In this episode, we make an input module and an output module with recording capabilities so that we can use the modules like a Eurorack system. Pure Data allows one to load patches as abstractions into other patches and use them like modules that can be mixed and matched. We do exactly that int his episode. We can now take our granular synthesizer and our tape looper and utilize them with the delay and ring modulation effect modules in a Eurorack-like system that can record to file.