Although I subscribe to M. Biederman’s view of M. Elkin, it’s nevertheless interesting to note that this cartoon was published in the same newspaper that was outraged by the depiction of late M. Rabin in S.S. uniform.

One of the difficult things to handle, for me at least, has been bidirectional communication between the interface (TouchOSC) and the sound generator (Logic Pro, in my case). Translating OSC events from TouchOSC to MIDI messages that Logic Pro can understand is fairly easy, thanks to OSCulator. However, getting things such as toggle buttons to work properly and reliably is something that has proven to be somewhat intellectually challenging (in a relative way, of course). I was therefore quite happy when I discovered I could find still another use for an iPhone, iPod Touch or – better still – iPad: a fully-functional recording light. You’ve seen it all over the place: the kind of luminescent fixture which says “ON AIR” or “RECORDING” or something to that effect, and which essentially warns the person about to open the door to the studio that the tape (or what’s left of it these days) is currently running. This tutorial will show how you can turn your $200-$700 iOS device into a recording light, saving you at least $111 in the process (and helping you show your clientèle how hip, classy or frivolous you are by hanging iPads and iPhones all over your studio).

I’d also like to point out that TouchOSC is $4,99 and OSCulator is around $20. Plus you get to pick up your recording light at the end of the day to check your mail.

Start by designing your recording light. With the free TouchOSC Editor, this is easy. I named the page “RecordingLight”, added a couple of Toggle Buttons (called, surprisingly, “toggle1″ and “toggle2″ in my setup). They won’t be used for input — obviously the recording light will be protected behind a glass fixture. I’ve also created a “Label V” object which will, soon enough, hold a “RECORDING” text string (it’s a V object rather than an H because the entire Layout Orientation is horizontal, a quirk which should someday be fixed). The label’s text size has been set to 70, but the text string itself is empty, so that nothing is displayed unless recording is taking place. Upload the TouchOSC file into the iOS device as usual.

Now, in Logic Pro, add a Recording Light control surface device (Logic Pro > Preferences > Control Surfaces > Setup…, then go through New > Install > (other) Recording Light). Set the device’s Out Port to “OSCulator In (8000)” (presuming you’re using the defaults) and the Input to “OSCulator Out”. This makes sure the device’s bidirectional communication is going through OSCulator.

With this basic setup out of the way, start recording in Logic. If everything is working properly, OSCulator will add a new event based on what it received from Logic. It should be something akin to “/midi/note/2″ with three parameters (pitch, velocity and trigger). Click on “0: pitch” and select Edit > Demux. Then start recording in Logic again. The event in OSCulator will change to the specific note sent by the Recording Light device: “/midi/note/2 > 25″.

If you’d like to know what’s happening in more detail, use Kurt Revis’ excellent (and free) MIDI Monitor software. This will show you that the “Recording Light” control surface in Logic simply sends a C#0 Note On message when recording, and a corresponding Note Off message when recording stops.

Now we need to tell OSCulator to send these events to the two toggle buttons we’ve created in TouchOSC so that they light up at the proper time. On the “1: trigger” line, select the Event Type “OSC Routing”. This means we’ll be translating the MIDI event into a custom address (or destination). Under “Value” select New and create a new Rewrite address called “/RecordingLight/toggle1″ (remember, this is the name we gave to the first toggle button in TouchOSC). Then duplicate the “1: trigger” event by pressing Command-D. This allows us to send the trigger to another control, the “toggle2″ button. Under “Value”, select New and add a Rewrite address called “/RecordingLight/toggle2″. The toggle buttons in TouchOSC will automatically react properly to Note On and Note Off messages.

Finally, when recording takes place, we’d want the (initially) empty label we created to say “RECORDING”. This should be replaced by an empty string when recording stops and needs to be set up manually. The two different message rewrites will be defined using an option in OSCulator’s Route Editor. Duplicate the “1: trigger” once more and set its Rewrite address to “/RecordingLight/label1″. Double-click on the “Arguments” cell, delete everything in the Arguments field that pops up and type RECORDING followed by a space. This will have the effect of setting the label1 control to the string “RECORDING” whenever recording in engaged in Logic. At the bottom of the window, set “Route when” to “The value goes from 0 to positive”.

Duplicate the “1: trigger” event one last time and set its Value to the new Rewrite address “/RecordingLight/label1″ with a new argument: Alt-Space (the only way I could figure out of sending an empty string to TouchOSC – it will look a bit funny in OSCulator but it works). Set the options to Route when “The value goes from positive to 0″. This will make sure the empty string is set when recording is stopped.

The above setup works flawlessly in Logic. The on/off states of the recording look like this, assuming you’ve hanged your iOS device somewhere in sight:

Off

On

This is a pretty basic application of using TouchOSC to fake an “official” control surface in Logic. I was trying to do the same thing with more complex devices, hoping to remote control Logic with a customized interface. By that I mean, of course, proper bidirectional communication (such as getting Cycle, Metronome & Record buttons to stay lit and mirror the state of the sequencer, or displaying SMPTE timecode). Remote controlling Logic with simple one-way messages in TouchOSC is another story, is very easy to do and has been done many times.

A one-way remote controller

The devices I’ve tried to analyze — Mackie Control, Logic Control, iControl and TranzPort — all proved difficult to emulate with the current state of OSCulator and TouchOSC documentation. Whether using SysEx or Continuous Controller events, the above devices’ messaging schemes are a pain to figure out and translate both ways properly (at least in the limited time I have for such experiments). If anyone cares to study further I’d be glad to hear about it.

If you’re the organized type, dressing such a list in Excel can be a pain. For each timecode value entered, you have to type three separate colons so as to obtain, e.g. 10:00:00:00 (asking for a clip that starts at 10000000 will usually get you nowhere). Moreover, if you want to do a few basic calculations (e.g. finding the total duration of all footage coming from a particular agency), you have to go through them with a separate timecode calculator and then waste half a day copying and pasting. I’ve tried to create a formula which would handle all of that but I got lost, quickly, in Excel’s cryptic syntax. And I didn’t feel like learning how to program Excel.

Luckily, as often happens on the third paragraph, an easy and effortless solution exists. A Swiss company, Belle Nuit Montage, has posted on its website an invaluable little macro which goes by the positively baroque name of TC.XLA 1.1. (with Drop-Frame). This little marvel was written more than a decade ago by Matthias Bürcher and will take all timecode formatting and calculating tasks in Excel off your hands. There are versions for Macintosh Excel 4 & 5 – and even DOS! – however the version called “Macintosh Excel 5, downloadable for OSX” is working perfectly well in a more up-to-date environment (in my case, Excel 2004 running on OSX Leopard).

Unfortunately, the English version of the webpage comes with very few instructions (the French version is much more explicit). The idea is very simple: you have to launch the XLA file (either by opening it or by adding it to your default macros). This adds two new styles (which can be found using Format > Styles…), called Time Code and Time Code DF (for Drop-Frame). All you have to do once you’ve applied these styles to your cells is to type the timecode without the colons – much like you would do in Final Cut Pro or Avid – i.e. typing 10000000 will result in 10:00:00:00 being displayed. This isn’t half the story, though.

TC.XLA running in Excel 2004

TC.XLA adds a dozen of new and handy functions that are very simple to use. You can now easily add and subtract timecodes, convert between frame rates and even find the value of a timecode in feet for 16mm or 35mm film. The macro seems to support all standard drop and non-drop frame rates, although I’ve only worked with it in 25fps (which is the rate the code defaults to if you don’t specify another one).

The syntax for the functions is very simple and is described on the Belle Nuit Montage website. As an example, entering “TCminus(E4;D4)” into a cell will give you the timecode difference between the values in E4 and D4. Presuming the two cells represent IN and OUT points, the result is obviously the duration of the shot. You can then easily add up a list of those durations with TCsum. This last function doesn’t seem to refresh properly when changing values upstream, but forcing a recalculation (Command-=) solves the problem. This is a minor niggle, though, compared to the ease of use and practical value of this tiny piece of free software.

Update: The above works fine for Excel 2008 as well, however you must press Command-Option-T after creating your workbook in order to enable the macro. The status line should respond with “TC-XLA 1.1″ followed by a URL to confirm this.

Update II (May 21st, 2010): To all current and future commenters, please understand that I cannot offer support for this plugin because I haven’t programmed it. It is apparently a hit and miss affair, some people having lots of luck with it and others getting quite frustrated with the whole thing. I myself can’t understand why the macro behaves the way it does. I’ve emailed the author, suggesting to upgrade the plugin, but apparently it cannot be upgraded and “somebody would need to write it from scratch using VBA”. There is, honestly, nothing more I can do about it.

DISCLAIMER: My knowledge of linux is superficial. I write the following with the intent of helping out newbies such as myself. Do not hold me reponsible if you follow my method and end up with a system that’s pushing up the daisies.

NOTE: This method has been tested on GNOME, the default desktop environment for my distribution. I haven’t tried it with KDE and, now that it’s finally working, I don’t think I will.

ACKNOWLEDGEMENT: I would never have gotten Python 2.6.1 and Ubuntu to work together if it hadn’t been for the precious help of wacky, a member of the Python forum, who saw me through several nightmarish reinstallations of both Ubuntu and Python. Several of his suggestions have been incorporated into the steps below.

I suggest you read through the entire list of steps so that you have an idea of what’s going to happen before actually running any command.

1. Install a fresh copy of Ubuntu 8.10 if your system has been hopelessly pulverized by repeated tests, errors and packages scattered in the wrong places.
2. Before doing anything directly related to Python, you need to install the packages listed below. The list is an amalgam of several suggestions I found around the web, so one package or more might not be absolutely essential. But since it works, here’s the list:
   • build-essential
   • libncursesw5-dev
   • libreadline5-dev
   • libssl-dev
   • libgdbm-dev
   • libbz2-dev
   • libc6-dev
   • libsqlite3-dev
   • libdb-dev
   • tk-dev

   The easiest way to install a package is to use the aptitude command. Make sure you’re connected to the internet, open a terminal session and type the following: sudo aptitude install package-name You will be prompted for your password the first time you invoke the sudo command, which executes everything typed after it as a “superuser” (or “root” user). Instead of entering the command for each and every package, you can may prefer to enter them all at once (all of the following should be typed on a single line): sudo aptitude install build-essential libncursesw5-dev libreadline5-dev libssl-dev libgdbm-dev libbz2-dev libc6-dev libsqlite3-dev libdb-dev tk-dev

3. Download and extract the Python 2.6.1 source. From inside the source directory, enter (still and always, one single line):
   ./configure --prefix=/home/yourusername/python/2.6This will setup Python to install into a ‘python/2.6′ directory inside your home directory, far away from anything system-like. You may choose to simply name the directory ‘python’, but the ’2.6′ subdirectory will help separate the installation from yet another custom setup, such as version 3.0, if you ever need to install one. Note, though, that this doesn’t mean I’ve tested the steps described in this tutorial with Python 3.0.
4. Compile Python with the standard command:makeWhen the compile process finishes, read the few last lines it printed: you might get a couple of modules which can’t be found. I don’t remember their names but from searching around I gather that a lot of people can’t seem to find them and that nobody really cares. Most importantly, make sure that you don’t get a module missing error for zlib or readline, which are essential for the following steps. The packages installed previously will have taken care of that, though.
5. Install Python. I tried to do a make altinstall (after going through the Python source readme file), but for some reason I ended up without an executable. So just go through a regular install. Since you’re installing the Python files into your home directory, you don’t need to use sudo:
   make install
6. Now, if you enter python in the terminal you should get the default Python version that comes with Ubuntu (currently 2.5.2). Typing which python should point to /usr/bin/python, not to the directory you just installed 2.6.1 into. All of this is normal and is actually what you’re looking for.
7. Optional: if you need an additional Python module (such as Numpy), install it from its source directory by typing: /home/yourusername/python/2.6/bin/python setup.py install --prefix=/home/yourusername/python/2.6 This runs the setup script using the 2.6.1 interpreter and installs the module into the 2.6.1 directory structure (since we’re using the same prefix we specified when installing Python itself).
8. Create a symbolic link to the 2.6.1 interpreter so that the next step doesn’t blow up in your face: sudo ln -s /home/yourusername/python/2.6/bin/python /usr/local/bin/python2.6 It is important that you do not use a different name of your fancy for the link. Now, if you enter python you’ll still have 2.5.2, whereas entering python2.6 will launch, well, 2.6.1. This will also make sure that non-system versions of Python have to be run explicitly. Keeping the ‘python’ command reserved for the exclusive use of the system’s Python version is likely to avoid headaches in the future.
9. In order to use the easy_install command which facilitates the installation of additional modules, you first need to install setuptools: download the egg file for Python 2.6 and enter: sh setuptools-0.6c9-py2.6.egg This is the reason why the symbolic link created in the previous step must be called ‘python2.6′ (the setuptools script runs a python2.6 exec command and will complain about a missing 2.6 version if it’s not linked with ‘python2.6′).
10. Optional but highly recommended: install IPython, an enhanced command-line environment for Python. Do not download anything manually. With setuptools installed, you can simply go into your Python bin directory (with cd /home/yourusername/python/2.6/bin) and type: ./easy_install IPythonApparently you may also enter the following directly, which saves you the directory switching part: easy_install-2.6 IPython I haven’t tried it myself, though. Anyway, download and install will be automatic.
11. You have to add the path to IPython to your terminal environment, so that the executable can be launched from any directory. Add the following line to the end of the .bashrc file which is located in your home directory. PATH=$PATH:/home/yourusername/python/2.6/bin I suppose you could create a symbolic link instead but i haven’t tried it.
12. If you use Geany for Python development, you need to edit one of its configuration files so that the application’s Run command executes the proper interpreter: sudo gedit /usr/share/geany/filetypes.python Modify the run_cmd line to read: run_cmd=python2.6 "%f" This will use the symbolic link you created earlier.

You can now run IPython, develop in the Geany IDE, and still install packages through aptitude or the Synaptic Package Manager without all hell breaking loose. If you’re using a tiny screen and touchpad I strongly recommend installing GNOME Do to avoid mousing around too much. Enjoy.