QuartzCrystal is an offline renderer that turns Quartz Compositions into portable QuickTime movies. It supports 3rd party plugins, as well as patches that do not work in safe-mode-only environments (such as QuickTime Pro). It also supports software scene antialiasing, so if you have a Mac with plenty of RAM and a hard-core video card, you can make spectacularly beautiful renderings of your plugins, effects, and compositions.

Beside QuartzCrystal, the only other product that renders and encodes compositions to movies is Apple’s own QuickTime Pro, which doesn’t support plugins, unsafe patches, or antialiasing.

Lately I’ve been working on integrating (or, more accurately, attempting to integrate) the Python scripting language into some plugins for an application we develop plugins for. We’ve wrapped many libraries with varying levels of success, so this one wasn’t going to be much different. Or, so we thought.

Technically, we’re interested in “Embedding” Python — We have a native Objective-C application that needs to make use of the Python interpreter at various stages of execution. The Python scripts are user-supplied, and are exceptionally free-form: the functions they write can take variable numbers of inputs, produce variable numbers of outputs, and can use any Python modules they have installed.

Unfortunately, this makes the embedding process somewhat complicated: From Objective-C, we need to be able to parse the script, find all its functions, and get all those functions’ input and output parameters. From this data, we can expose the Python module’s interface usefully. Unfortunately, Python does not appear to allow this kind of introspection from the outside (and it’s questionable whether or not it’s even possible from the inside.)

In searching for information on this, Numerous Documents are Found that Needlessly Complicate or Obfuscate the difference between Embedding and Extending. As if it’s really that difficult (embed means “fix firmly and deeply in a surrounding mass” while extend means “cause to cover a larger area; make longer or wider”. From these obvious definitions, we can infer that “Embedding” means putting something inside, while “Extending” means adding functionality or abilities. Maybe it’s not so clear for non-native english speakers. I don’t know.)

Another annoying side-trip of this research was an overwhelmingly smug idea that almost reeks of Java. This side effect is the recorded smarmy discussion of why one should “Extend” rather than “Embed” (these reasons are then used to explain away why there isn’t any good documentation on actually embedding Python). The arguments go something like this:

• Python’s so good, cross-platform, and flexible that it’s actually more cost-effective to Throw Out All Your C/C++/ObjC Code And Rewrite Everything In Python.
• Embedding is so cumbersome to code, and so difficult compared to embedding Python in Python, that you should Throw Out All Your C/C++/ObjC Code And Rewrite Everything In Python.
• High-performance code can be written in C, and then called from within Python’s runtime when you actually need to performance boost. Why not just Throw Out All Your C/C++/ObjC Code And Rewrite Everything In Python Except for the fast bits?
• If you embed Python, you’ll annoy Python developers who can’t access the modules they’re used to using. Why not Throw Out All Your C/C++/ObjC Code And Rewrite Everything In Python so you don’t annoy your Python developers?

These arguments cover some pretty diverse ground there. Unfortunately, there are 2 fatals flaws in the list above.

First, embedded Python _Can_ in fact use installed modules just like raw Python, so point 4 above is flagrantly incorrect. There are some suggestions that it’s simply annoying to develop in such an environment because namespaces are all strange (or wrong) and nothing works quite right. Guess What: Welcome To Plugin Development! It’s like these Python developers have never worked on real projects before or something.

Second, All of the above points assume that it’s possible to discard your entire code-base and rewrite everything. While this is technically possible, it’s not very likely when you don’t have access to the source of the application to be discarded (in our case). The unfortunate downside is that _All The Listed “Solutions” Hinge On This One Idea_.

What’s with these non-solutions from allegedly flexible languages? Even Objective-C, a compiled language, and the (totally undocumented) JavaVM-ObjC bridge, offer enough introspection to at least find methods and parameter counts without too much hassle. Maybe Python does this just as simply, but if so, no one’s talking about it…

Along with the new site, a few new patches are available as well based on requests from users.

New this time:

• MIDI Global In Note :: This patch observes a specified MIDI Note number on a specified MIDI Channel, and outputs the Velocity and a boolean Gate signal.
• MIDI Global Out Note :: This patch, when Gate is rising true, outputs a MIDI note-on message on a specified MIDI Channel with the specified Velocity. When Gate is falling false, a MIDI note-off message is sent.
• Image With Composition :: This patch loads a Quartz Composer Composition (.qtz) file and renders it to an Image. (This is intended to replace functionality that was removed with the Mac OS X 10.4.7 update, as described by Roger Bolton and David Wolf.)
• File Type :: This patch provides the Uniform Type Identifier (UTI) of the specified file. For example, if the path to a QuickTime movie is specified, File Type outputs “com.apple.quicktime-movie”.

This release is only compatible with Tiger (10.4).
Please see kineme.net for Leopard-compatible patches.

Get them here: http://softpixel.com/~smokris/widgets/quartzComposer/kinemePlugins/

MIDI Global Output CC :: This patch, when triggered, outputs a MIDI Custom Controller message on a specified MIDI Channel to all MIDI outputs.

MIDI Global Input CC :: This patch observes a specified MIDI Custom Controller on a specified MIDI Channel, and outputs the Custom Controller Value and a Value-changed trigger. Unlike the “MIDI Controllers” patch that comes with Quartz Composer, this patch doesn’t require the user to manually select the “Observed MIDI Sources” individually for every controller/computer combination - so you’re free to take your composition to a different machine and/or controller and jam without needing to hack the composition.

String With File :: This patch reads a file into a string.

String With URL :: This patch retrieves a URL into a string.

Document Info :: This patch returns some information about the zeroth Cocoa NSDocument.

This release is out-of-date.
Please see the latest version.

Get them here: http://softpixel.com/~smokris/widgets/quartzComposer/kinemePlugins/

(digg this!)

I scantlandishly asked him, “Steve, how long do you think it would take to get kineme to the point that we could capture four streams of video, mix them in realtime, and output to QuickTime for mastering in DVD Studio Pro?”

He kurtruffishly launched into a brief coughing fit.

I continued by telling him that in about two weeks would be the annual Hilliard Davidson High School alumni choir concert, and that I intended to use it for this.

He hit me.

We planned out the new computer hardware we would need for kineme version 0.8.0.

We ordered it this morning.