What you’ll need:
- Ableton Live (free demo here)
- Quartz Composer (free, how to install here)
- MadMapper (free demo here)

This is the end result you gonna get when finished:
(scroll to the end of the tutorial for a video)

The idea behing this tutorial is to use Ableton Live as a sequencer to drive realtime Quartz Composer graphics, mapped using MadMapper.

For this tutorial, we’ll pass some information between different applications.
Since we’ll be using audio to automatically sync the mapping, we’ll use the MIDI protocol,
which is widespread and hopefully free with every Mac.

On the Mac, there’s a loopback allowing to share Midi data internally. It is called the IAC bus. And you’ll have to enable it.
Go to your /Applications/Utilities folder, and launch the “Audio Midi Setup.app”.
In the menu, select Window / Show Midi Window.
Then select and double click the IAC box and enable the bus (check “Device is Online)
as shown here:

Great, you just have an IAC loopback bus configured.

Now launch Ableton Live.
By default when creating a new Live project, you have 2 tracks, one Audio track and one Midi track:

We won’t need the audio track, so select it (click on its title) and get rid of it (press delete).
Rename the Midi track to “Midi to QC” – with this track we’ll send midi data to QuartzComposer.
Create an extra Midi track (CMD + SHIFT + T) and rename it to “Midi to Audio”.
This track will use the first midi track to get its data from and generate some sounds.

Let’s configure the Midi so that everything works.
Just to be sure, go to the Preferences (in the menu), then select Midi, then set your midi ports to enable IAC bus:

Now we have to set the correct midi inputs/outputs for the tracks.
In the track IO settings:

- set the “Midi to QC” track:
______MIDI from: NO Input
______MIDI to : IAC bus | Channel 1

- set the “Midi to Audio” track:
______MIDI from: “Midi to QC”
______Monitor: IN

Congratulations, the boring part is done.
Now the fun:

Create a new midi pattern in the ‘Midi to QC” track
(right click, insert midi clip), like that:

Select that box, and expand its content
(the black arrow at the very bottom right of the Live window).
Now we’ll make some notes to drive the visuals.
We’ll use 4 notes for this tutorial (but you can use more of course),
starting at C5 (then C#5, D5, D#5).
I’ve made a sample rhythm:

Drag an instrument (I’ve used a Bassline from the analog library) on the “Midi to Audio” track. This instrument will actually produce the sound of our project.
Here are the settings (shown when clicking the black arrow at the very right bottom of Live window):

Click the play buttom and you should have some sound magically coming from your speakers, since we dropped an instrument on the “Midi to Audio” track, namely a bassline. Note that you can put any other synth you want …

Wow, the Ableton Live part is over ! Keep the app open and playing.

Locate quartzComposer, make sure it runs in 32bit, by right-clicking the app, select “Show Info”, then select “Open in 32 bit”.
Then start Quartz Composer and make a blank project. This sounds over complicated, but apparently it was causing problems in 64bit (see comments).

Drop a Clear Patch (bule) and a MIDI Note Receiver Patch (purple).
QC defaults the middle note to C5, but Ableton Live is C3. So for both apps to be on the same page, we’ll have to configure the MIDI Notes Receiver patch to Middle C3, just like that:

Middle note is now C3 in QC, and we listen to the C5 note range.

The next step is to add 4 sprites whose brightness will respond to the velocity of the midi notes sent by Ableton. Zuper-easy.
Drag 4 sprites, position them in each corner of the QC viewer.
I made them sized 1 by 1 unit, positioned at
x:-0.5 y:-0.5
x: 0.5 y:-0.5
x:-0.5 y: 0.5
x: 0.5 y: 0.5

Then connect the notes receivers to the color pins of the sprites, like that:

Since QC is working with normalized floats (0.0->1.0), the Midi velocity (range 0->127) is automatically scaled to the sprite’s color (range 0->1).
If Ableton Live is still running and playing, the sprites should blink according to the rhythm you just made. Bravo, you’re now officially an Audio-Visual Performer.

Save your QC file and close QC.

Launch MadMapper (version 1.4 minimum), import your freshly saved QC file, and select it to activate it in the input view.
Modify the parameters like that (no need for a huge resolution):
Width = 512 pixels, Height = 512 pixels.
We’ll be working with squares – original isn’t it ? -

Now make 4 quad surfaces, each selecting a different portion of the input, like that:

Finally, you can work on your mapping and modify the perspective of each quad.
Since the QC content is white, we can use MadMapper to modulate the color of each quad.

Voila, it’s almost finished.
The principle is here, now hook up your projector and start mapping.

Here’s what we did at the office, on a 3d-printed object, using only these 4 notes, and some masks…

This is the neutral object:

The MadMapper setup:

And the video result, using exactly the same file we did in this tutorial:

- Quartz Composer (free, how to install here)
- MadMapper 1.4.2+(free demo here)

Let’s get started.

Open up Quartz Composer and create a new blank file.
Drop in some picture of yours, place a Billboard patch in the composition and connect the image to the billboard, just like that:

Insert a filter in the image chain. I’ve used a Color Controls patch, to modify Brightness,Saturation and Contrast:

Now, we want to push some parameters so that we can tweak them in MadMapper directly. Right click on the Color Controls patc, and select “Publish Input”, then select Saturation:

Repeat the same for Brightness and Contrast.
Right click the Billboard, and publish the Color as well.

These 4 parameters will now appear in MadMapper’s interface, auto-magically.
Now add an Interaction patch (note that some people have reported problems with this patch when using Mac Osx 10.8), and connect it to the Billboard like that:

Save the QC file.
Launch MadMapper and drop the QC file into the input section, click it to activate it in the input view. See how the parameters when published now appear in MadMapper’s media inspector section:

You can now tweak your parameters. I’ve changed the color to red, and added some contrast:

The final part of this tutorial is the interactive mode.
When clicking on the [i] button in the inspector – it will turn blue -, MadMapper will pass the mouse information to your QC patch (but only in the input view). You can now click on your billboard, and move it somewhere else… :

Et voila ! You’ve learned the basic principles of parameter publishing.
Congratulations, we wish you some good fun tinkering with QC and MadMapper…

Note: here’s a list of the input types that you can publish into MadMapper:
- numbers (with/without range)
- indexes (named, limited, unlimited)
- strings
- colors
- booleans

MadMapper won’t recognize the following inputs:
- Mesh
- Structure
- Images

Big up to Llyod Blankfein for participating in this project.
Thanks bro’ for driving our planet.

Note to QC-fans: the show is running entirely with _1024_QC Plugins

As a bonus here’s a schematic showing the whole setup:

It was the perfect show according to our standards, everything went fine, despite 2 computer reboot during the show – thanks to the super tech team nobody noticed – and some heavy hum coming from the Midi cable … grrrr

Next show is in Cran-Montana, Swiss.

And the last one, which looks like a proof that 1024 is actually bending the light … ;) Space Warp anyone ?

All photos by BUC/Mirage

technical info for da nerd:
4 Video Projectors 20k @1024*768
each projector was Space Scanned using MadMapper
Custom QC based software
26 LED rgb fixtures
DMX flashlights
DMX control over the existing facades
Lots of custom QC plugins
Running entirely off a single MacPro