MFL in a drumkit
The goal of the project was to create a drummer-friendly performance environment for my solo project Endre-eNerd where Live reacts instantly to all commands and the desired scenes/clips can be launched without losing sync, I get visual feedback about the playback status of the performance and every aspect of the performance can be controlled from the drumkit without having to drop the drumsticks.
More info on the show can be found here:
The setup contains a series of MFL plugins, of which the most important three ones will be covered here.
There is a long explanatory video on YouTube that speaks for itself, demonstrates all three plugins and shows their use in action:
Having the video, I didn’t think there would have been any point writing a long essay on what the plugins do. The sections below were simply extracted from the video and can give an idea on what the setup can do, but it is highly recommended to watch the video in order to fully understand the potential that lies in the system.
The video from which the software chapters were excerpted also demonstrates the hardware components of the system and gives some more usage examples:
“Today, when they sell way more electronic drumkits than acoustic, I still see that drummers are somewhat intimidated by electronics, which is a pity, because drummers are the first to be told by their band leaders before going to the studio that “you don’t need to come and play, we’ll manage with a groove library”.
And this is exactly why drummers should be aware of all the technologies which other musicians use for drums and maybe even strike back and take electronic drumming to a further level and do some of the things which are normally done by other band members or even DJs.
I’ve always been interested in using electronics in my acoustic drumkits and like for most drummers it started with simply triggering some samples and sound fxs, but I always wanted to do something more complex and tried to take full control of electronics without sacrificing my musical freedom and spontaneity.
I wanted a setup where I could interactively communicate with the sequencer while playing the drums. There has always been a problem with taking sequencers on stage in improvised music and it was a great leap forward when Ableton Live appeared and took the interactivity between musicians and computers to a further level, but even Live has its limitations which make it difficult to take full control of it while playing an instrument, so in many bands you’ll see a DJ or someone who deals with the computers only.
Unfortunately most software were not designed with drummers in mind and we had to do some serious development to come up with a system I needed. One might wonder what I mean exactly by saying “not designed with drummers in mind” you might ask the question what makes drummers so special that they’d need special tools?
By my view there are two crucial differences to other instrumentalists and DJs. One is that while playing the drumkit we’re like Captain Hook or Edward Scissorhands and have no free fingers to type on a computer keyboard or touch some delicate knobs and faders and even more, we normally don’t have any free limb to stomp on a foot controller either, so our only way to communicate with the outside world is to hit things with a drumstick, which is not really welcomed by most objects.
The other difference between us and other instrumentalists is that drumming is about “now”. We’re certainly not like DJs who can peacefully listen to what’s coming next, then check their emails, play some computer games while waiting for the changes to become audible to the audience. We expect instant response on whatever we do on the drumkit and most softwares are not designed like that so that was our biggest challenge while creating this setup.
The setup has some custom built and customized hardware pieces and some software components.
Once the MIDI signal hits the computer, the rest has to be done by the software. The main sequencing host of the setup is Ableton Live, which is surely the most widely used daw software on-stage, but for me it took quite a while to make a decision of building the whole system around it, and the reason for this was that it wasn’t designed with drummers in mind and some of the key features I needed were missing from it, until Ableton launched MFL, the development environment which finally made it possible for us to develop the plugins I needed for my performances.
This is not a Live tutorial, so I’m not going to spend time on explaining how Live works, but I’ll tell about how I use it and what our custom plugins do.
A quick word about what the features I missed most were: most people I know use Live on stage with the quantize value set to one bar and trigger the next clip or scene during the last bar of the currently playing part.
This approach might be good for most instrumentalists, but certainly not very convenient for drummers, for two main reasons: during the last bar of song parts we often play fills, when we don’t really have a free limb to launch new clips and also -as I mentioned earlier- anything we hit in a drumkit reacts instantly, so it feels kind of awkward that you hit a pad and nothing happens until we get to the next bar.
So I wanted to have a solution where everything I do on the drum pads would be instantly executed in my Live session. If you’re familiar with Live you might think this is no big deal, setting the quantize value to None would do exactly this which is right in theory, but wouldn’t work in a real life situation.
Just consider that all the acoustic pieces in the drumkit have zero latency: you get the sound immediately when you hit them, but this is not the case with electronics. It’s not so apparent when you just trigger single samples, but things can get really bad when trying to layer several loops on top of each other. So in certain situations it’s virtually impossible to play a kit where half of the playing surfaces have zero latency and the rest has a slight delay.
When you hit a drumpad, the impact of the drumstick virtually immediately creates a trigger signal, but this signal has to go through a number of processing steps before we can actually hear anything. The first stage is to convert the analog trigger signal to MIDI. This takes a few moments usually ranging from 1 to 4 milliseconds -depending on the hardware and the settings.
As I mentioned I use the good old MIDI protocol for its stability, so in my case this delay must be around 4 ms. Once the MIDI signal hits the computer, it must be determined what that signal will do: whether it will launch a new scene or clip, or it will play a sound of a VST instrument or perform a mixer control action like muting or soloing a channel or it will control the playback transport etc.
So, this step also will increase the latency and then the sound has to be generated and sent to the output of the audio interface which again adds some more delay to the signal. So a lot of things must happen before we get any sound and what makes things even worse is that this latency is different for each action type, so the delay of the signal will be different when launching a new scene from the delay when triggering a sound of a VST sampler instrument.
And most importantly we mustn’t forget that we’re humans -at least most of us keep trying to be- and we play with minor inaccuracies which is a very good thing for getting that signature groove but it’s definitely no good for triggering loops, which in most cases should happen precisely on the beat or on an other point of the quantize grid and this is especially true when you want to layer multiple loops on top of each other and all these little inaccuracies add up and make the whole texture sound very sloppy.
So to sort out these latency and inaccuracy issues we developed a Max For Live plugin that makes it possible for me to trigger everything instantly without losing sync.
So when I trigger a new scene or clip it starts to play back immediately and then the plugin makes up for the latency and makes the playback of the newly launched parts aligned with the grid. And because we’re talking about very tiny inaccuracies in the few milliseconds range, in most cases it’s not audible at all when the plugin is in effect and makes these minor adjustments.
(…) The plugin is switched on all the time and applies to most clips in the set, but if a track name starts with a star sign the clips on that track will bypass the plugin which can be useful in some cases. The plugin works silently in the background, it has no fancy user interface, just a number of initial parameters like how fast the playback adjustments should be done…
The operation of the plugin is based on a similar technique that’s known from software samplers, which only store the initial portion of long samples in the memory, so that the playback could start immediately on hitting a note on the keyboard and the playback of this initial chunk gives the software enough time to retrieve rest of the sample from the hard disk and continue the playback from there.
This technique makes possible the low latency playback of those huge multisampled instruments which don’t fit the memory.
Similarly to this, my clip synchronizer plugin launches the clips immediately without any quantization and after a predefined time a quantized shadow clip will take over the playback.
Setting up a Live set for the plugin is quite complex so we have no time to go through all the steps now, but the plugin itself has only one adjustable parameter. This value tells the plugin how long it should take to make the playback aligned with grid. So for example setting this value to 1/4 means that the playback will get quantized in 1/4 after launching the clip or the scene.
This is a plugin that makes it really easy to program what the drum pads do in a specific Live scene.
If you have a trigger to MIDI converter, you know that you can assign a MIDI note to every pad and these assignments can be saved in setups or kits, which can then be recalled, so that when there’s a song where this pad plays a vocal effect and this one plays a brass section fall and then a new song comes where the same pads do something completely different, the new note assignment for all pads can be recalled by a single command.
But because the same pads can be used to control more than one thing during the performance, programming can get excessively complex and very hard to maintain with multiple devices. The pad-to-MIDI converter’s setup changes always have to be in sync with the currently playing scene, otherwise the pads might do something that belongs to a totally different part of the set.
So to keep thing nice a tidy, I decided to leave the pad to MIDI converter alone and use a single setup for the whole performance and make all the MIDI note assignment changes internally in Live and this is handled by this plugin. It collects all incoming MIDI notes and translates them into other MIDI notes which correspond to the currently playing scene within the Live set. So this makes sure that the right note assignments will always be recalled at the right time and that all setups will be stored in the Live set.
These two fields show the incoming MIDI notes and the two fields below them show the outgoing notes generated by the plugin. There are four operating modes:
- Block mode means that the incoming notes will get swallowed, so there’s no outgoing note.
- Cycle mode is the most common operating mode. The root note is the first outgoing note that the plugin will generate for the selected incoming note. The Steps parameter sets the number of adjacent notes to cycle through with the outgoing notes. So e.g. if it’s set to 1 the Root note will be the only outgoing note, setting it to 2 will cause the plugin to alternate between the Root note and one semitone above it. setting it to 3 will tell the plugin to cycle through three notes: the Root note and the two semitones above it and so on. The note length parameter sets the length of the outgoing notes and Threshold sets the minimum velocity required for an incoming note to activate the plugin.
- Random mode is similar to Cycle mode, but instead of cycling through the specified range of notes chromatically, in this mode the plugin will randomly pick an outgoing note from the specified range. And finally, in bypass mode the outgoing notes are always identical to the incoming notes.
When all my pads are set up in the plugin, the kits can be stored and recalled by MIDI program changes. The MIDI clips which transmit the program changes are placed into the right scene so launching any scene in the whole set will always recall the corresponding note assignment for all my drumpads.
This is a very useful plugin that gives me visual feedback on the currently playing scene and the playback pointer and it can also display reminders before hitpoints. … So it’s as if I had the scores for the whole show but only the current row would be visible which saves me a lot of space and it’s always in sync with the playback pointer.
The plugin has no adjustable parameters, it only has a Reopen window button which does exactly that: it reopens the playback status display. The window layout is very straightforward: on the left side it shows the name of the currently playing scene, the name of the next scene and the name of the previous scene.
On the right side there is a time display that shows the playback position in a bars and beats format.
Below this section you can see the playback pointer strip. Bars are separated with the green lines and the number of bars represent the length of the current part of the tune. This obviously doesn’t mean that all clips must have the same length for that scene, so for example it’s no problem to have a 2 bar loop in an 8 bar verse, but the length of this strip will always represent the length of the song part that’s playing back.
When I launch a new scene, the display reflects this action and shows the current scene name and length and the playback pointer bar is always in sync with the playback position.
Seeing all this information during the performance is really great, but the plugin has some more very useful features. It can highlight the important hitpoints of song parts and can display messages about them:
The highlighted bars are shown in red and the related text message appears at the bottom of the plugin window. I often use this feature and use a very simple scoring method for the messages, which can be easily read by anyone who’s a little familiar with step sequencers or drum editors.
Setting up the plugin is really easy: just create a guide track with a clip for every scene and insert the plugin into that track. The length of the clips should correspond with the length of the song part they belong to as this will determine the number of bars shown in the playback display strip. If there are messages you want to display in the bottom row, just type them into the clip name, start with the number of the bar they should apply to and separate them with commas and you’re ready to go.”
How did this project use Max?