Getting Around in Radial, Part Three

Creating Your Own Interface

In the previous installments, I've tried to give you a quick hands-on feel for how radiaL operates, paying particular attention to how you can develop a feel for radiaL's nonlinear playback modes by listening. But I think that the place where radiaL really shines as an instrument rather than enjoyable way to do multi-channel loop manipulation involves the addition of an interface -- connecting radiaL to an external controller in a way that turns your favorite parameter changes into physical/gestural activities. In radiaL, the files that describe the relationship between parameters and an external controller is called a control template.

The process of creating your own radiaL instrument -- setting up a control template for use with radiaL -- is a personal one. Once you begin to develop a feel for how radiaL sounds and what kinds of parameters you enjoy working with, sit down and look at your controller.

• What kind of configuration of radiaL are you running?

• How many channels?

• How many effects?

• What kinds of knobs/dials/sliders/switches do you have on your controller?

• What kinds of control are most important to you in a live performance?

My own general goal is to move as much parameter control as I can to external controllers (and this also includes being able to use your computer keyboard, too). In my case, the only time I really use the mouse at all in live performance is to load files to a loop channel, use the track pad as a sort of KAOSS pad now and then, or to fine-tune a p/t grid setting.

I'd describe my basic approach to using radiaL as an instrument as follows: First, develop a feel for how radiaL's parameters interact and affect a loaded audio file. As you do this, start thinking about groups of parameter settings you find particularly pleasing until you can hear a loaded audio file and immediately imagine how to start modifying it.

The first two installments of this series concentrated on encouraging you to do just this. This installment is about what to do with the insights you've gained from working with the software. I think that the key element to using radiaL as a performance instrument is to start making your own personal interface as soon as you can -- that is, move as much of the operation of radiaL to an external controller to speed up the process of starting to work intuitively. Once the transformations you like are not only second nature but also physical gestures, I think you're freer to start "listening" as you perform.

Setting Up Your Own Control Template

So, how do you go about transforming radiaL from an enjoyable playground for loopery into a performing instrument? The procedure is pretty straightforward (and both radiaL and I will help you with the process).

The radiaL application lets you create and edit your own control templates using the Control Map window. To see the MIDI controller editor, choose Control Map from the Elements menu or type command-K.

If you don't have a manual or MIDI listing for your controller handy, you can use radiaL itself to help you figure out what parameters you want to change. To use radiaL's Controllers window, choose MIDI Control Setup from the System menu. In addition to letting you configure radiaL to use various types of controllers, the Controllers window lets you monitor inputs from controllers and your computer keyboard, too.

Choose your external controller from the pop-up menu.

You'll notice that when you turn a knob, move a fader, or use a switch on your external controller, the green LED will flash and you'll see a pair of numbers. The first one is the controller number itself, and the second number is the value the controller is sending (if the controller is a switch, you'll notice that it only sends a 0 or 127).

If you want to use your computer keyboard as a controller (after all, it's really a huge bank of switches, isn't it?), the matter is a lot easier – you simply type in the name of the key itself.

Once you know your controller numbers, you can create your own entries for the Control Map window, and save it as a text file you can reload. The radiaL manual contains a complete description of how to use the Control Map window, and radiaL itself comes with a couple of control maps already set up for your use for controllers like a Peavey pc1600, or a Doepfer Pocket Dial, or a Motormix.

If you don't have one of those controllers, it's just a matter of choosing the parameters you want to control in the left-hand column, and then filling in the modes and input/output values. Setting up a control template is something you really only have to do once. You can reload it again, or make it your default control map in the radiaL application.

Here's an example of what the process looks like. This Oxygen8 I've got in front of me has a few knobs I can use, and a MIDI keyboard (An Ozone has the same basic configuration and – as a default – the same controller assignments for knobs, so you can use what I'm going to set up with it, too). I've got an upper row of 4 knobs [which the Controllers window tells me correspond to controller numbers 10-13], a lower row of 4 knobs [controller numbers 14-17], the mod wheel [controller 1], and – of course – the keyboard itself.

Here's what it looks like to set up a parameter for a control template. I'd like to use the lower row of knobs to control the gain on each of four loop channels. So here's what it looks like for channel 1 (using MIDI controller 14).

I want to use the upper row of knobs to control the filter cutoff frequency for each loop channel. That one's a little more complicated, since I'm specifying a slightly unusual output range (20 Hz. – 18000 Hz., and exponential scaling), but not too hard to figure out.

When it comes to using a synth keyboard, there's an often overlooked radiaL parameter called inspect.loop.keyboard that's really useful in live performance. If you associate your external interface's keyboard to this parameter, you can use the keyboard to transpose whichever loop channel you are using the Inspector to examine (and remember that the number keys on your computer keyboard are used to select loop channels). This means that you can independently transpose all of your loops individually using only one parameter. Of course, you can dedicate a single loop channel to work as a kind of sampler create a control template that uses the kpitch parameter for that specific loop channel to control its pitch – it's your choice.

By the way – in the first two installments, you may have noticed that there are two different ways to change the pitch of a loop – the pitch/time grid and the kpitch parameter you can access using the Inspector for a loop channel. Why are there two different ways of controlling loop pitching? The answer has to do with the fact that radiaL doesn't use granulation to alter the pitch of a loop loaded into a loop channel to keep the apparent pitch of the loop constant; instead, it makes its best guess about the nearest playback rate to keep loops in sync, and plays the loop back at that rate (which changes its pitch). In practice, I use the pitch/time grid as a way to "tune" a loaded loop's pitch with respect to other loops that are also loaded and running, and then I use the kpitch parameter to perform transposition.

I've decided to use the inspect.keyboard.loop parameter for use with my Oxygen8 controller, so here's how to setup the control map template to use the keyboard:

I think that makes pretty good use of my Oxygen8 controller's knobs, but I'd like a little more performance flexibility. So it's time to think about using my computer keyboard to set up some control parameters for live performance. I'm already going to be using the keyboard to enter values and use the track pad from time to time, but maybe there are some other radiaL parameters I could put under my fingers (here's the part where you think long and hard about what parameter combinations in radiaL you like to use,, and decide there you'd like to put them on the keyboard so you can work quickly. Are you left or right handed? If you like making lightning-fast parameter changes, do you want to put the toggles on neighboring keys, or split them between your right and left hands? Don't be afraid to take a little time and try out a number of options until you find the collection that makes the most sense to you.

When putting together my performance interface, I've decided that I like to select only a small portion of an audio file loaded on a loop channel, so it'd be great if I could use a row of keys (let's say z, x, c, and v) to toggle between having the whole loop selected (the default) and only a one-fourth slice of the loop. Here's what the control map entry looks like:

Since I've got a row of knobs that handle filter cutoff frequencies for each of my loop channels, it would also be great if I could toggle the filters' resonance values between normal operation and a high Q value that will "ring" or oscillate. To avoid accidentally hitting those keys, I'll assign them to the q, w, e, r keys on my keyboard, like this:

Once you've gone through and set all your parameters up in the way you want (at this point in your performing career, anyway) you can click on "save current as default" to set these values as your default control map.

When I'm making control templates, I usually save a copy as a text file for tweaking and working with later on, as well.

Control Maps and Text Editors

Once you're familiar with the Control Map editor (or once you start to really spend a lot of time with the interface you create), it may occur to you that there's really no easy way to create a control map in which a single parameter can be controlled by more than one key or continuous controller (I certainly ran into it, and I'll bet that you will, as well). In that case, I'll let you in on a little secret: with only a little attention and effort, you can edit radiaL control templates as text files, and add the functionality you crave.

I learned how to read a control template text file using the tried-and-true "brute force" method: I created a "new" control map that included only one change I was certain I'd made, saved it, opened the file in a text editor, located the parameter name, and looked at the file. So I can save you a little trouble.

Remember the trick where we used earlier where the computer keyboard was used to toggle between low and high Q values for the filter a loop channel? When I set that up for my Motormix, here's what the text version of the template looked like.

chan_1.filter.high.Q, 77777 mm 57 toggle 0 1 lin 1. 6.;

Every line in the template file looked pretty much the same — a list of things I recognized from the Control Map editor, and a semicolon at the end of every line.

Apart from that bunch of sevens [which don't appear to do anything at all], the end of the line looked pretty familiar to you (toggle 0 1 lin 1. 6.;) – it's the same sequence you'd type into the Control Map editor. The rest of the line is easy:

1. The name of the parameter

2. A Bunch of sevens that you can just copy and ignore (as far as I can tell)

3. the controller type (mm for Motormix) followed by the controller number. If I were using a different type of controller, the line would read cc (continuous controller) instead.

So, I reasoned that if I wanted to control a number of parameters with a single controller or a key from the keyboards, all I'd have to do was duplicate that line of the file, change the parameter names, save the file and then reload it. For my test, I set the "q" key to simultaneously toggle high Q values for all the channels at once:

chan_1.filter.high.Q, 77777 key q toggle 0 1 lin 1. 6.;

chan_2.filter.high.Q, 77777 key q toggle 0 1 lin 1. 6.;

chan_3.filter.high.Q, 77777 key q toggle 0 1 lin 1. 6.;

chan_4.filter.high.Q, 77777 key q toggle 0 1 lin 1. 6.;

It worked great! But the reason I was really excited was that I realized that I could think about having a single parameter controlled by more than one key or controller – I could set up "master" switches that affected all channels at once in addition to having single channel controls. That made a terrific change in the way I thought about designing my instrument interface. And creating new control templates by cutting and pasting from other text files is a snap. Once the editing is done, you choose read control map from file from the Control window to load the file, and then choose save current as default. The next time you launch radiaL, it will start up with your control map loaded and ready to go.

The Evolving Instrument

On some level, I guess that as I grew more familiar with my instrument in a physical sense, I was paying less attention to the physical/control side of things and more to the feedback loop of making a change and listening to the results as one goes along.

I didn't plan it this way, but just when things were moving along well, everything changed. Both jhno and I had been interested in working with live audio input in the context of radiaL for a while, and so we added that functionality—initially in the form of a VST plug-in that allowed live recording, and later including that functionality in radiaL itself. I decided to test the new functionality by performing live with it, duetting with my percussionist friend Tom Hamer.

Almost immediately, I realized that my "old" solo radiaL instrument wasn't well configured for working with live input – I found myself using considerably fewer loop channels for live performance, and also noticed that the subset of radiaL parameters I tended to use in live performance was also different.

I mention this bit of history to make a point – your experience with an instrument consisting of software and an external controller is best described as an iterative loop process; you create the instrument you thing you need, work with it for a while, and then gradually begin to change and extend your original ideas in ways that extend your vision while allowing you to maintain your physical "sense" of the instrument you're using.

My performing life consists of two very different instruments, although they both consist of my Motormix and radiaL. My "solo" instrument uses 8 loop channels and a couple of VST effects, and is heavily oriented toward controller mappings that manipulate the playback parameters [the "Inspector" parameters] of a loop. The instrument I use when performing in an ensemble has fewer channels (4 rather than 8), controller assignments oriented toward more control of loop recording on the fly and more controller real estate set aside for routing audio to VST plug-ins. An interesting side effect of trying to perfect theses interfaces was that I initially found it confusing to move between solo and live performances early on—the controls that I had had "in my fingers" and didn't have to think about in the course of several years of performing were suddenly doing very different things on my 4 channel instruments. I had to relearn my instrument. I still have trouble transitioning from solo to ensemble instruments, going so far as to prefer to do the gigs on different days, with some time to "warm up" on the instrument I'll be using.

That sounds like a real instrument to me.