Production technique: virtual audio CV, MIDI LFO and drum trigger extravaganza

[ras.s]

Here's a bit of something I came up with recently. This technique has probably been abused by others before me, it's quite experimental.

So far I've come up with three applications for it: to create a sort of an audio control voltage to control side-chainable effects, to create an MIDI LFO to control synthesizers and the host mixer and third, to create automatic drum beats.


It goes like this:

Add a tone generator. I used MeldaProductions MOscillator, but anything will do, including a regular synthesizer. The benefit of a tone generator is that it's always on, it doesn't need to be triggered by a MIDI track. Obviously, the benefit of using a synthesizer instead is that the signal can be killed at will.

Add a tremolo effect on the tone generator. I went with MeldaProductions' plugin again, MTremolo. It's very comprehensive. This makes the sound of the tone generator to pulse, in sync with the beat or not, and with MTremolo, it's easy to design stepped sequences as well.

After this, you can add another tremolo on top of it to make the pulse do exactly what you want.

At this point, the signal can be used as a side-chain signal. Connect it to a compressor or a gate and you've got some pretty interesting effect. For instance, I had an aux send effect that contained a delay, a gate and another delay. I sent a track to that aux and what it does is that it feeds the signal to the first delay, but the gate ducks the signal (makes it silent) according to the tremolo. The last delay then echoes what passes through that gate.


The next thing that's possible is to use the magnificent insert piz here's plugin AudioToCC to create a CC from that audio signal -- it's pulsing to the the beat like an LFO. The most recent version of AudioToCC allows sending the MIDI data to external devices and what I did was I sent it to MIDI Yoke (in the box virtual MIDI i/o). I then enabled MIDI Yoke as an input in my host, allowing the CC to control parameters on the mixer. This can be used for automatic adjustment of pan, volume, effect send and so on.

Enabling that MIDI Yoke (or the output of a modular subhost) as an input for a synthesizer allows controlling its parameters according to the tremolo - basically it gives the synthesizer extra LFOs, no automation involved.

The third thing to do with the tremoloed signal is to use it as an input for a drum trigger (drum replacement) plugin - something that sends a MIDI note to drum synth/sampler when the signal hits a certain threshold. On Windows, the KTDrumTrigger is a classic with plenty of options. There are others too, like the free DSP Trigger. Having several different tremoloed signals as inputs for the triggers lets the experimentalist to create automatic drum beats. In modular hosts, it's easy to have several tremolos connected in serial, yet snatching the signal after each tremolo to do a certain thing.





There are other ways to do this whole thing, like using a MIDI LFO plugin to begin with, but I think this gives the user a lot of control over the shape of the curve that is created - and the side-chain thing doesn't even involve MIDI. And a great thing is that none of this requires any automation.

[ras.s]

To summarize the idea, I should have written in the first paragraphs something like "The idea here is to create a audio signal with steady volume, then vary that volume with effects and use the processed audio signal for some voodoo."


Anyways, here are some screenshots of how to set this stuff up (right-click -> View, to see larger than what they appear here).

First, a drumbeat generator with stock Studio One plugins (a step sequencer, if you will).



What happens in this picture is that there are three empty audio tracks all equipped with Tone Generator, X-Trem and Gate. The stock gate in S1 can output a specified MIDI note when it hits a threshold. It's not volume sensitive though.

Those gates then are used as the MIDI input on the Impact drum sampler. It takes three more tracks to have each gate work as the inputs.

The audio signals from the Tone Generator tracks (BD, SN, HH Trig) are sent to a group channel, I named it Trigger Osc. The purpose of this is that the sound has to go somewhere, otherwise it doesn't work. The group can be muted or as I did here, I sent the signal to a yet another gate on the Drumbus-group channel to tighten the audio.

What's also going on in the picture is the big green blocks, that is, I'm recording the MIDI from the drumbeat.

If you really want to try this trickery, I suggest you go with MTremolo for the volume modulation and DSP Trigger for the drum triggering part. The benefit of those are that MTremolo can be used for longer sequences than the 16 steps the stock plugin can handle and that DSP Trigger is velocity sensitive in regards to the MIDI it sends out.

Now why would anyone want to do this and not just use a step sequencer? Well, the chances are, if you don't have a decent step sequencer, you might still have these other plugins (and they are free, anyway). Another thing is that depending on the tremolo effect you choose to use, you can modify the beat on the fly with a MIDI controller, for example, using a fader to change the start position of the modulation, thus changing a beat without further editing. It's also quite fast to make a backing track, if you're just playing with synthesizers (practicing, etc). Plus there's the possibility to create totally random stuff that loop.



Next up, is the AudioToCC, here's a screenshot from the modular area of EnergyXT.



How this setup functions is that I load this project with the plugin version of eXT in Studio One. That track then sends four flows of CC, both at the MIDI output of eXT and also through MIDI Yoke (it can send it straight away to external devices as well).

This gives your synthesizers and mixer extra LFOs.

The AudioToCC plugin has a mono switch, that is, each instance can also work in stereo, sending two flows of CC modulation instead of one. So what's in the screenshot could also send eight such flows - to make it more useful obviously, one would need to modulate also the panning and not just the volume of the audio signal coming from the oscillator. This then again opens a whole can of worms when it comes to unexpected ways of modulating stuff.

This can be done without a modular subhost, too. Create a audio channel with the oscillator and tremolo and add midiAudioToCC from the piz after those. Then you need to arm the synthesizer with the midiAudioToCC plugin as a MIDI input. The difference between AudioToCC and midiAudioToCC is that the former has more features but doesn't work with Studio One and the latter has less features and no GUI, but does work with S1 and it's crossplatform -- this performance may differ in different hosts.



And third one is the side-chain thing. Here's another shot from Studio One.



This admittably looks more complicated than it is, but I was experimenting with stuff and didn't want to delete the things that are unused at the moment.

So again, there's a empty audio track, equipped with a tone generator and tremolos, this time from the Melda suite of free audio goodness. This track creates the pulsing audio that is used as a source of side-chain signal. There are several sends on that track, namely: Gate2 & Gate4 (they're on the "Stop delay" FX track) and a send to "Osc modif", which is a track that further modifies the audio signal coming from the oscillator.

The oscillator track is again sent to a group channel that is in this case muted - the sound of the oscillator beating isn't something you want to listen (well it might back up as a drum track..).

There's an instance of bongDEMO here, a hihat channel that is further sent to two auxes, Stop delay and Reverbish delay, though the latter is not in use at the moment. So the Gate2 on the Stop delay-effect channel kills the signal everytime the oscillator hits a threshold (I've activated the 'duck' option in the gate plugin). A sort of an rhythmic gate.

The way I've set up the "Osc modif" channel here is that the tremolo opens the oscillator on the first of the beat and the delay makes it tap. This then is sent to a gate on the "Reverbish delay" channel - the gate (Gate5) comes after a reverb that has a ten second tail. What this does is that the reverb can be heard only when the delay taps - it's a very different kind of effect in the realm of echo, but still a variation of a rhythmic gate effect.

Other applications would be surgical precision NY compression or adjusting certain area of the frequency spectrum with a side-chained equalizer in pulsing motion.




Perhaps someone finds this monkey business to be of some use. It's at the edge of being overly complicated or not and probably would have been of more use back in 2004 when there weren't so many LFO plugins we have today (there are like three or four of those today, and Bitwig will have modulations built-in). It does give quite a lot of control over what can be done though with the modulated oscillator signal.