Sunday, 2 February 2014

Resonate - Windows Standalone

As promised, here is a standalone Windows version of the program, get it here:

Resonate 1.0 Win

A bit untested, but seems to work fine. The only strange behavior is that (on my machine, at least) you need to close the program form the task manager. Not sure why this is at the moment, but will update this post if I solve it.

Wednesday, 22 January 2014

Creative Convolution Part 1 - Resonate



Convolution reverb is a great thing. Its usual use - being able to capture and re-create spatial acoustics, is useful for a range of tasks such as fitting dialogue in a scene, or just creating a sense of space. But it's worth taking a moment to think about what is happening during this process. One sound file is effectively being filtered through another, with the convolution reverb filtering the frequency content of each sample through all the samples present in the IR (a simple explanation, but adequate here). The impulse response files themselves effectively hold a snapshot of the acoustic data of a space, or at least from a point in the space. This data describes how the room responds acoustically to an impulse or short burst of broadband noise. So essentially, you could think of this in a different way, about sound files as containers of information - acoustic information. But this data is made up (like any sound file) of frequency content over time, so the convolution reverb process is potentially useful for much more than just recreating the acoustic space of a room; it is effectively a kind of filter, and that is the main subject here - an exploration of that idea. 

I once heard a really useful definition of timbre: “spectral footprint over time”.
From a sound design perspective getting the correct timbre for a sound is important as it connects the sound to its source. Interestingly, we naturally identify sounds back to their source (or object which created the sound) rather than by their acoustic properties. This explains why timbre is so important - it immediately describes the source, ie hollow or metallic, and gives the listener an impression of what created the sound.
 

If you found your way here, I expect you might be familiar with this SoundWorks video for the making of Inception. I really love the bit at 3:20 where Richard King is describing the subwoofer recordings they made in the warehouse. There is something fascinating about how powerful and complex about the natural resonances of the space are.  

 





I've long had an interest in physical modelling as a technique for designing sounds, so when I saw that video I started wondering what it would take to achieve the same results artificially. Would it be possible to model the space and materials of a location like that and produce some useful sounds? 

I think that understanding some of the principles of physical modelling are useful not just for creating sounds to use, but also to help explain how and why sound works in the way it does. I've done a few experiments in Max using filterbanks and basic waveguides to try and simulate real-world physical resonances with varying degrees of success, but experimenting with convolution about a year ago, I discovered some interesting techniques which are related…it started with a set of recordings like these:

 

These are impacts on various metal objects recorded with a contact transducer. If you’ve ever used one of these, you will know that one of the great things about recordings made in this way, is that they are completely dry, this is because the transducer only picks up the vibrations traveling through the object itself. It means that you can go anywhere to record these sounds, even next to busy roads where a conventional microphone recording would be useless because of noise from the road. So I recorded a whole library of these, experimenting with different objects and different methods of striking them.

It was while doing this that I had the realisation – this process is exactly the same as taking impulse responses of rooms, I was just collecting acoustic data. But when taking an IR of a room, you are collecting data about how the room behaves acoustically, and these recordings contain data about the resonance properties of the material. The broadband noise used in recording an IR in a room, such as a balloon burst, is comparable to the impulse created when striking an object. They are both a burst of broadband noise followed by their effect on something – in the case of the room it is the reverberant characteristics, with a material it is the resonant properties.

Here’s an example of these sort of sounds used as IRs in a convolution reverb, you will hear a dry vocal sample, then the sound of the impact recorded with the contact transducer, then the vocal sample through the convolution reverb with the impact loaded as an IR. You can hear how the original sound is filtered through the resonance properties of the material:



It’s interesting to note how sounds with a long decay still create a sound with a reverb-like quality to it, but sounds with less decay create more of a filtering effect. 

Around this time two other things caught my attention. Firstly, Alex Harker and Pierre Alexandre Tremblay, both from Huddersfield University, released the HISS Tools - a collection of Max objects designed for pretty much any convolution operation you can think of (and a few more besides!). If you’ve used the Max for Live convolution reverb before, they are at the heart of it. For sound designers these are an amazing addition to Max, as they allow anyone to integrate convolution reverb into any patch quickly and easily. Huge thanks to them for making these objects publicly available.

With this in mind I started sketching down some ideas for a Max patch that would take advantage of these. It began as a kind of configurable resonant space, partly inspired by techniques used for mixing sounds together in game audio, and partly from the experiments I’ve been describing. 

The second thing that caught my attention at that time, was this post at Designing Sound by Douglas Murray, focusing on his use of convolution reverb  to create infinite airfill using white noise as a sound source. Up until this time I had been using a range of sounds to ‘excite’ the IRs, but this was another direction, and really made so much sense for creating ambient, atmospheric sounds. It’s a great technique, and as an extension you can increase the resonance by stacking up multiple instances of convolution reverb loaded with the same sound as an IR. Here’s an example similar to before but with one, two, three and four instances of the same reverb running in series.

 
When using white noise as a source, with one instance of reverb you will always hear the noise coming through to some degree, but with two or more instances the sound becomes progressively more filtered and the dominant harmonics of the IR become accentuated.

Be careful if you want to try this inside a regular DAW – there will need to be some heavy gain reduction somewhere in your signal chain, otherwise extreme clipping will result!

Sounds of this kind are really useful for creating evocative ambiances or adding some extra resonance to metal hits and scrapes. I like the idea of having a palette of sounds like these, based just on texture, using these in layers the same way a painter would with oils on a canvas.

So how about expanding this idea? There is certainly scope with this. I spent a bit of time designing sounds for this purpose, and that is definitely worth pursuing, but I’m not going to go too far into them here. Instead, I want to talk about another technique for generating interesting sounds for use as IR’s. Whilst designing specific sounds, I started experimenting with using music tracks as a source for IR's. I’d snip out small sections of music with interesting harmonics then load them as IR's into multiple reverbs and play noise or filtered noise through them. The resulting sound is like a constant smear of all the frequencies present in the music, sounding similar to the results you can achieve with granular synthesis but with a richer sound. Bored of slicing music up manually I made a small utility patch to automate the process. It takes a sound file and chops it into smaller slices. The patch is fairly crude, but it works fine for the purposes of this article. To work flawlessly it really needs to be a phasor-synchronised system, (feel free to improve it if you like, but send me a better version if you do!). It’s reasonably straightforward to use, just follow the instructions.




Here is a link to the patch:

Chopper



So that's a bit about the history of where the idea for this device originated. It actually references a whole bunch of work shared by other people, and tries to bring those ideas together and create something new. For me, this is all about tool building. Taking a process and re-thinking how it could work, combining existing technology in new ways to create new possibilities. It takes this process which in a DAW is very clunky and frustrating and reimagines the process. Everything here would be achievable with separate effects within a DAW, but in reality what you can achieve here in minutes would take hours of setting up and tweaking. 

Here is the result, it is a device which explores resonance, filtering and spatial positioning.





There are three sections to the patch, The sound source, the nodefield and the effects section. The sound source creates the sound used to feed the IR section of the patch. There are currently three options here:
  • Noise Gen - A simple noise generator with amplitude envelope and sweepable filter.
  • Grain Player - A basic granular file player, built around Timo Rosendal’s Grainstretch~ external.
  • Loop Player - A vari-speed looping sound player with pitch and amplitude envelope capabilities.

The middle section or what I've called the node field is the unique part of the device. Here, there are eight FX lanes, each contains 2 IR reverb objects in series. This is the signal flow inside each:




The output volume for each effects lane, or node, can be linked to the node weighting (ie, how far into the node area the crosshairs are). This is a linear value form 0-100% volume. Panning can be linked to the position of each node across the X axis of the node field. If this is turned off, the user can adjust the input volume of each by using the multislider at the top of each fx chain. Pan position can also be linked to the position of each node across the X axis of the nodefield. This generates a stereo field across the X axis of the node field, so sounds can swept across the resonators. There is a central system which distributes audio files to the convolution reverb objects; this allows you to put all the sound files you want to use as IR’s in a folder, point the patch to that folder and then quickly choose between them from a menu system. A pair of LFO's are linked to the position of the cross hairs in the node field, these can be used to sweep across the nodefield, providing a spatial approach to mixing. There is also an envelope control labelled 'input gain scaling' which defines the shape of the gain slope, so you can have linear, exponential or any other gain curve, or even more complex, experimental patterns.

The effects section below comprises of the following:
  • Harmoniser - Splits the audio stream into six, providing pitch shifting, delay and pan on each channel.
  • Filter - A basic multi-mode filter
  • Comb Filter - Sweepable comb filter
  • Distortion - A combined bit crusher and overdrive distortion box. Signal path is crush>drive.
  • 2x VST/AU effects - Load in whatever you like here.
  • IR Reverb - Very basic convolution reverb. Comes pre-loaded with some IR's from the OpenAIR library 
All the effects are combined using a matrix, so you can route audio through them in any combination, in parallel or in series. There is no feedback protection, so be careful there.

I expect you're asking what does it sound like?

Well I've been using it in a particular way, and have had that in mind through the development phase. But really it is just a combination of playback devices and effects, so use it however you see fit. Having said that, here are some examples, these are straight out of the app using the built in effects - no fancy external plugins.

First up, a selection of static drones created with the white noise source. Note how the frequency fluctuations of the white noise add subtle but continuous variation to the drones:



These are some metallic resonances created by using the contact mic recordings above as IR's


Here is an evolving drone which also uses white noise as a source but sweeps over the IR's using the LFO:




This is a granular example. It takes a recording of a music box and plays it backwards with some position variation, it then filters this through some snippets of a female choir used as IR's




Here is some more radical granulation - frozen grain sweeps with some extra harmonic richness from the IR section.



These sequences use white noise as a sound source. The noise has a rhythmic amplitude envelope and filter sweep applied to create an almost steam-like mechanical sound.





Saturday, 11 May 2013

æ - ʊ - ʌ - i - a - ɜ



Formant Synthesis


I'm currently working on quite a large project which brings together the ideas from the two previous posts, so I thought this would serve as an interesting sound design interlude until I get that finished.
  
Formant: (Acoustic Phonetics) One of the regions of concentration of energy, prominent on a sound spectrogram, that collectively constitute the frequency spectrum of a speech sound. The relative positioning of the first and second formants, whether periodic or aperiodic, as of the o of hope at approximately 500 and 900 cycles per second, is usually sufficient to distinguish a sound from all others.
(dictionary.com)

That definition of formant points to some interesting information about how we listen and communicate. This is potentially very useful for the purposes of sound design; different vocal sounds are constructed from combinations of formants at different frequencies. This is one of the key factors which allows us to distinguish between different vocal sounds and words, an attribute which has developed organically with our ability to communicate. Whilst speech synthesis is the most obvious area this is useful for, a potentially interesting task for a sound designer is creating vocalisations for fictional creatures (for example in fantasy or science fiction genres), and it can be assumed that if they are organic and have developed as we have, then similar rules will apply. 

Here is some interesting reading on constructed language (conlang) and creature sound design courtesy of Darren Blondin.


Formant Synthesiser

So here is a device for formant synthesis built in Max/MSP. This is heavily based on a patch from Andy Farnell's excellent book Designing Sound, so all credit for the basic design goes to him. If you're interested in real-time synthesis of non-musical sounds there is (to my knowledge) no better book. There is an introductory chapter to the book available as a free PDF, which also makes a great introduction to pd. Even if you intend to do all your patching in Max, the ideas and patches from the book are easily transferable.

Farnell's example patch "Schwa box" is built in pd (as are all those in the book), so I've adapted the patch to work in Max, and have added in a few extra features such as adjustable pitch and vibrato. It currently uses a basic synth patch as its sound source, but could easily be adapted to use audio recordings. This would then make it possible to add human vowel-like resonances to other sounds.

Download the patch here: 


As ever, you will need either a full version of Max/MSP 6 or the Max/MSP 6 runtime. Both are available from Cycling '74 here. The runtime version of Max allows you to run patches but not edit them.

The speech formants are modeled with [reson~], the resonant bandpass filter which is one of the standard MSP objects. As soon as you load the patch it should start making sound. You can see the frequencies of each formant as it cycles through the vowel sounds.

 Below is a chart detailing the individual frequencies. Note how they are not at harmonic intervals and do not have any regular spacing.

(Compiled by Tim Carmell, spectral database at Center for spoken Language Understanding, Oregon University)

These frequencies are defined by our anatomy, specifically the size and shape of the human supralaryngeal vocal tract (SVT). As we speak, the SVT continually changes shape to create the different formants needed for speech, producing a frequency pattern which changes over time. In the patch, we are using bandpass filters to physically model the resonant characteristics of this space. 

Interestingly, the specific anatomical traits necessary for human speech did not develop until the Paleolithic period (50'000 years ago), so both Neanderthals and earlier humans were physically incapable of what we consider human speech. We do not develop the ideal SVT dimensions until around 6-8 years old as the mouth shortens, the tongue changes shape and the neck lengthens during this time.

If we need to be scientifically accurate with our approach to designing creature sounds, we first need to ask some questions about the creature: 


  • Is it intelligent enough to speak?
  • Does it live in social groups, and therefore have a need for speech?
  • How will the anatomy of the creature affect the sounds it creates?
  • What is its native habitat, how will this affect its vocalisations?

So the formant synthesiser in this post addresses point three on that list, and covers part of a setup which could be used for creating creature vocalisations. There is also room for expanding the system; by changing the list of resonant frequencies this could model larger or smaller creatures (lower frequencies for larger creatures). 

On a side note, some VST users amongst you may have already encountered formant synthesis in what must be the most conceptually important plug-in ever created, the Delay Lama:





It doesn't get any better than that.
 

  




Friday, 12 April 2013

Tapehead - Sample Playback for Sound Designers




For this, the first post, we're going to look at a simple device which utilises the sample playback capabilities of Max/msp - essentially we are making a playback device. It's fairly basic, but can be expanded on in the future to create a more complex system (more on that later). I'm not going to cover how to re-create this device step-by-step, so this post assumes that you have a basic competence with both Max and msp. If you've gone through some of the tutorials or spent a bit of time noodling around with Max you should feel at home here.

In part, this was inspired by a story which stuck in my head about Frank Warner, sound editor on Raging Bull, Close Encounters and a whole host of other great films. Here is a section from it, part of an interview with Walter Murch in the book Soundscape: The School of Sound Lectures:


'He [Frank Warner] would take one of the reel-to-reel tapes from his huge library and put it on almost at random and move it with his fingers. He'd just move it manually, at various speeds, backwards and forwards across the playback head. Meanwhile , he'd have the recorder turned on, capturing all these random noises.... But he was in the darkness, letting the breeze blow through his brain, waiting for the kernal of an idea that would emerge, fragments of unique sounds on which he could build everything else'


(Murch, 1998)


Being able to play sounds back at different rates is one of the oldest, but still one of the most useful techniques for creative sound design. This device is designed to facilitate simple pitch manipulation in a way that is playful and experimental, embracing a bit of randomness and the unexpected along the way. The idea is to load up a recording, and experiment with just playing back the sample data at different rates and in different directions. There is no musical tuning, no measurements in semitones and cents, just the waveform, playback time and the playback pattern over that time. 

Here is the link to download the patch:

Tapehead 1.0 

You will need either a full version of Max/msp 6 or the Max/msp 6 runtime. Both are available from Cycling '74 here. The runtime version of Max allows you to run patches but not edit them.

(This patch is tested up to Max version 6.08, the current version 6.12 has issues with the replace message to [buffer~] so will not work, if you do have problems try an earlier version)

The best thing to do is load a sound and flick through the presets, try selecting different areas of the file, different playback times and shapes. With the breakpoint editor shift-click removes points and alt-click+drag adjust the curve if in curve mode. You can also drag the manual scrub bar at the top and scan over manually.

So this doesn't exactly break new ground, as this is all possible in most DAW's, but it does provide a convenient tool for experimentation. Also, within your DAW this is usually achieved through editing and off-line effects such as the pitch-bender. This player is capable of changing playback direction and position very quickly and specifically, and can control this using complex playback curves. The other key factor here is that as this process is live, there's no waiting for offline processing. 

I'm not going to explain how every single part of this patch works, but we are going to look at the main playback mechanism at its heart. Max has a range of different objects which can be used for sample playback, all which have slightly different attributes and capabilities. When I first started using Max I remember finding this quite confusing and overly complex, as sample playback is considered a really basic capability of any audio system. However, I soon learnt that with this complexity comes versatility, and that through this Max is capable of creating a range of sample driven instruments or playback systems. 

These are the objects associated with sample playback:

sfplay~
groove~
wave~
2d.wave~
play~

The first on the list, [sfplay~] is the odd one out here, as it plays back from disk. The others all play from an object called [buffer~] so the audio they use is stored in memory, like a sampler. 

With Max I often find that making a connection between two different objects is the inspiration for a device, and that's what happened here. I was tinkering with an object called [function] which is usually used for creating envelopes of different kinds and thought of a slightly unorthodox use for it; driving a [play~] object to playback samples in interesting ways.

Here is a simple patch below which demonstrates the core of this mechanism:




Here's a link to the patch itself:

Tapehead Basic


And here's a step by step rundown of what happens inside:

1. You load a sample into the [buffer~] called soundA  

2. This triggers [info~] to spit out some information about the sample we have stored in our [buffer~]. In this case we are interested in the total time of the sample, or how long it is, at the sample rate which it was recorded.

3. Moving over to the [function] object (the XY graph), we first set a duration which it will cover using the setdomain message. The message box here will add the text setdomain onto the beginning of any message which passes through its left inlet.

4. Trigger playback using the button at the top of the patch. This causes function to pass on information about the breakpoints you've created to [line~]

5. [Line~] generates a signal matching the shape and time which you set for the function. So a straight line from 0-1, left to right is linear playback, forwards. The opposite - a straight line from 1-0, left to right is linear playback, backwards. Between this you can set a playback shape which scans the wave in any way you see fit, backwards or forwards.

6. As the output from [line~] is between 0-1 we use [scale~] to scale the signal up to the length of our sample.

7. The signal then drives the [play~] object, playing back sample data from the [buffer~] and outputting the sound you have created through the [ezdac~].


I've expanded on the device further by adding the manual scrub option, as that can often be a good way of discovering new sounds, and adds more of a physical dimension to the process. I expect everyone who uses this in Protools has accidentally discovered a sound which is more interesting backwards than forwards in this way! The rest of the completed application is composed of UI objects (menus, sliders etc) and other control objects like [preset]. The beauty of this patch is the potential for expandability here. Now we have the main control mechanism in place we can duplicate it to add in other parameters. Multimode filter with envelope control over cutoff and resonance? envelope driven adjustable delay line? Amplitude envelope? Envelope controlled pitchshift? LFO controlled vibrato? Envelope controlled LFO speed? A bank of presets for each effect? Randomised preset recall? It's all possible.

Please feel free to comment. I'll also be expanding the system in a future post, so keep an eye out for that. 





About...

This blog is all about using Max as a sound design tool, or (if you like) building tools for the purpose of sound design with Max.  As sound designers we share many tools with musicians and composers, and rightly so... it's all sound, after all. 

But is there scope for designing custom tools for specific sound design tasks that are not viable for mainstream developers? Tools like Max can bridge a gap, as they essentially provide the means for tool creation to the people who are using them.   

I've been using Max in this capacity for several years now and have built up a bunch of interesting patches over that time. I've finally decided to properly document these and make them public. If anyone else feels like they would like to contribute to this, please do get in touch. I'm always interested to hear from other sound designers using Max, and the more we share ideas and techniques, the faster the whole scene progresses.