QuickTime is all C function stuff, rather verbose and boring. It’s also 32-bit only. The 64-bit front end on it is a framework called QTKit. However, 64-bit QTKit is little more than an impostor that secretly makes things messier during the 32-to-64-bit transition.

At its heart, QuickTime relies on encoders and decoders, among lots of glue stuff. These encoders and decoders (collectively called codecs) are modular, so different systems can have different sets of codecs installed.

These codecs all have custom settings. To set them up, they each include a component settings pane. I suspect that these panes are written in Carbon, but I could be mistaken. Either way, the component settings pane is dispatched via the Components interface. 32-bit apps can’t dispatch 64-bit Component panels, and 64-bit apps can’t dispatch 32-bit Component panels.

At this point (and we’re barely doing anything interesting with QT yet!), we hit 3 critical problems:

1) Codecs at present are almost exclusively 32-bit. This means that enumerating codecs in 64-bit space gives you next to nothing interesting to play with.

2) We can’t access panels for Components that are of a different word size.

3) As a hack-around to “address” the problem 1, Apple decided that QTKit in 64-bit mode should start a 32-bit background process called QTKitServer that handles encoding and decoding when called upon to do so.

Now, “problem” 3 might not look like a big deal, but it actually makes things horribly contrived, incorrect, and neither forwards nor backwards compatible. Anything touching this is going to have some exciting ups and downs in the next few years.

Why? 2 Reasons come to mind.

First: The settings pane is still inaccessible. Sure, apps can ask for a settings description dictionary, and that’s likely to be a start, but it will not be the same as the Carbon Settings Pane UI that people have come to know and “love” over the years. Configuring and displaying the same settings will now be handled on a per-app basis instead of a system-wide one, which is a recipe for disaster. UI-wise, inconsistency is killer.

Second: Codec enumeration in this model is horribly, horribly wrong. QuickTime provides a simple API to get a list of all codecs on a system, but this is only available in 32-bit apps. Components (slightly lower level) are available in 64-bit, but they don’t list 32-bit ones when you’re in 64-bit mode (because they can’t be used anyway, so who cares). However, that secret background thread will use 32-bit components, and you have no way to know which ones are available short of writing a 32-bit background app yourself to query and fetch this. This Is Exactly What QTKitServer should be doing anyway, to make the transition smooth, but it doesn’t, so it won’t be. Rolling your own process to do this means more bugs, more duplicated code, and more problems when QTKitServer is no longer 32-bit (eventually there may be nothing but legacy 32-bit codecs, and an app that relies on this method will never be able to use modern 64-bit ones without an update, which may not be possible if the product is discontinued, the developer dies, the harddrive with the source crashes, etc). If the Server process told you what it sees, it would always be correct, and this wouldn’t be a problem.

So there’s no good solution for Problem 1 (well, NIBs/XIBs would solve this, but it’s not possible with the component API at present), and the “Solution” for problem 2 actually just makes more problems.

Maybe I should look into that MSDN subscription……

It uses the default sound device, by default. It gives you the ability to change the output device.

According to the documentation:

- (void)setPlaybackDeviceIdentifier:(NSString *)playbackDeviceIdentifier
	
Specifies the receiver’s output device.
	
playbackDeviceIdentifier
    Unique identifier of a sound output device.

That’s it. What is the “Unique identifier of a sound output device”? What format is this “Unique identifier”? How do I get a list of the “Unique identifiers” of the available output devices on my system?

No documentation exists for that part. Anywhere. Which makes this method kinda useless.

Maybe we can use the corresponding method, - (NSString *)playbackDeviceIdentifier? Nope, that just returns nil.

So, then, how do I get a list of output devices?

Turns out I need to detour from Cocoa and use CoreAudio’s C API directly. And even then it’s not documented very well. There was a request a few years ago to update the archaic, pre-OS X-era KB article, but that request has gone unanswered.

Can I get a list of output devices directly? Apparently not. But I can get a list of ALL devices, and then interrogate each device and get a list of each device’s buffers. Then I can interrogate each buffer and add up the number of output channels the device has in total. If there are more than zero output channels, this device is an output device!

I was able to piece together the following enumerator:

UInt32 sz;
AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices,&sz,NULL);
AudioDeviceID *audioDevices=(AudioDeviceID *)malloc(sz);
AudioHardwareGetProperty(kAudioHardwarePropertyDevices,&sz,audioDevices);
UInt32 deviceCount = (sz / sizeof(AudioDeviceID));
	
UInt32 i;
for(i=0;i<deviceCount;++i)
{
	NSString *s;
	
	// get buffer list
	UInt32 outputChannelCount=0;
	{
		AudioDeviceGetPropertyInfo(
			audioDevices[i],0,false,
			kAudioDevicePropertyStreamConfiguration,
			&sz,NULL
			);
		AudioBufferList *bufferList=(AudioBufferList *)malloc(sz);
		AudioDeviceGetProperty(
			audioDevices[i],0,false,
			kAudioDevicePropertyStreamConfiguration,
			&sz,&bufferList
			);
	
		UInt32 j;
		for(j=0;j<bufferList.mNumberBuffers;++j)
			outputChannelCount += bufferList.mBuffers[j].mNumberChannels;
	
		free(bufferList);
	}
	
	// skip devices without any output channels
	if(outputChannelCount==0)
		continue;
	
	// output some device info
	{
		sz=sizeof(CFStringRef);
	
		AudioDeviceGetProperty(
			audioDevices[i],0,false,
			kAudioDevicePropertyDeviceUID,
			&sz,&s
			);
		NSLog(@"DeviceUID: [%@]",s);
		[s release];
	
		AudioDeviceGetProperty(
			audioDevices[i],0,false,
			kAudioObjectPropertyName,
			&sz,&s
			);
		NSLog(@"    Name: [%@]",s);
		[s release];
	
		NSLog(@"    OutputChannels: %d",outputChannelCount);
	}
}

On my MacBook Pro, this currently outputs:

DeviceUID: [AppleFWAudioEngineGUID:18202415010545664]
    Name: [EDIROL FA-101 (0000)]
    OutputChannels: 10
DeviceUID: [AppleHDAEngineOutput:0]
    Name: [Built-in Output]
    OutputChannels: 2

Why couldn’t this have been as easy as NSSound?

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.

I have an Apple product once again. 黒林檎（くろりんご、kuroringo）is born!

Two weeks ago I committed myself to purchase a macbook to replace my aging IBM Thinkpad X31. The X31 had served me well for more then 4 years. Over the past year I had debated what laptop would best fit my needs. Although I quite liked the macbook I was put off by the increased weight. I briefly considered the Macbook Air only to conclude that the decrease battery life was not worth my time. In the end I decided to eat the weight and possible battery life restrictions of the macbook for the power and ease of OS X (not including not being able to print to a Sharp copier).

In any case after a false start whereupon Apple did not have a black macbook in stock despite listing it on their refurbished section. However I checked on 2008.07.09, and a sexy black 2.4ghz core 2 duo macbook was listed. I decided to go with regular shipping hoping it would arrive by the 11th. Hah! The 15th rolled around, and FedEx delivered the laptop about an hour before my peers would arrive up north.

So I concocted a devious plan to lure them into a false sense of security. I set this ebony beast of glory onto the port replicator of my X31, propped a Dell 5310n product info. sheet over the back, and then a white piece of paper over the keyboard.

After a delicious lunch an Pizza Hut we returned. Chris was the first. He passed right by, sat down, and opened his macbook. I sat down, turned on the power to the hear my blackbook chime for the first time. Chris mentioned, “Oh did you change your out-of-sleep sound to that?” Mission accomplished.

Steve walked in a little later. At this point I had taken no measures to disguise my macbook. His mind was pre-occupied with other matters, and he missed the white logo in a sea of black directly across from the office door. Over by the refrigerator I said, “Hey dude check it out…”

After a few moments of shock or disbelief came the inevitable, “Woah…”

They also missed the list of names that I had jotted down (descriptions added with my thoughts):

• obsidian: sharp, rock, sexy, and black
• fruitbat/okomori/ookoumori: sillier, but black and mobile.
• raven: meh…
• shikkoku: too phallus-y
• kuroringo: I had thought up kokuringo too with the same meaning, but see above.
• blacksheep: I liked this one along with obsidian.
• kurome: black eyes, meh…

Well, it’s been alright, but much to my regret the improved latency due to keystrokes only traveling around my local machine — instead of through the interweb and back as was the case with PINE on a remote machine — makes it almost justifiable. Almost.

Apple Mail makes it really easy to delete messages. You just press the “Delete” button. Poof.

Apple Mail, however, makes it a lot more difficult to SAVE messages. You have to go to the “Message” menu, then select “Move To”, then select the mailbox you want to save it in. Or use the mouse to drag-and-drop it into your mailbox of choice. But this is not acceptable as using the mouse depletes one’s indie cred even more than simply using a GUI mail client in the first place.

So, armed with James Eagan’s article on writing mailbundles I wrote a hack which adds a menu item, complete with keyboard shortcut, allowing the user to easily and quickly file one or more messages away in the “Sent” folder (*). See here:

(*) Since switching to Apple Mail — and having access to its nifty and swift full-text search capabilities — I’ve abandoned the thousand-or-so individual folders in which I used to file things away. Mail in my Inbox now goes to one of two destinations: Trash, for spam and automatic notifications and other stuff I have no interest in ever looking at again, or Sent, for anything written by a human and on occasion important things written by computers.

Download MoveMessageToSentFolder-1.0.zip.
Leopard (Mac OS X 10.5) only.

To install:

• Copy the mailbundle to ~/Library/Mail/Bundles. Create this folder if it doesn’t already exist.
• Open Terminal and run the following commands to enable mailbundle support:

  defaults write com.apple.mail EnableBundles 1
  defaults write com.apple.mail BundleCompatibilityVersion 3
  

But don’t give up yet, all you burgeoning totalitarians out there! For here I shall reveal a much simpler (albeit slightly less efficient) method of voting fraud. Here is what I learned in my absentee-ballot-casting experience. Oh yeah, and dear internets: please use this for good and not evil. And also don’t use it at all.

Today I cast my absentee vote for tomorrow’s Ohio presidential primary at the Franklin County Board of Elections. Like a good citizen, I arrived there prepared with my opinions and my state-issued, valid photo ID. I thought I was packing light by leaving my purse in the car and just grabbing my wallet, but it turned out I could have traveled lighter — you don’t need a photo ID, or any other kind of ID for that matter, to vote absentee. And, since there’s such a large window of time in which you can cast an absentee ballot, you can vote pretty much as many times as you want, provided you have enough people’s name, address, date of birth, and last four digits of their SSN.

Parking was hectic and when I rolled my window down to get parking instructions, I was assailed by propagandists from all sides. I was then directed to a parallel parking space into which the car barely fit. After that I waited in line for over an hour.

When I got to the voting booth without ever having been asked to so much as spell my last name, I asked an election worker, “Isn’t anyone going to ask me for identification?”

“They don’t need to,” she replied. “They have all that information in the computer.”

“So, it would be pretty easy, then, for someone to show up and pretend to be me?” I asked/commented.

“No, because there are certain things they wouldn’t know about you,” she said, matter-of-factly.

The absentee ballot request form requires a voter to fill out their name, current address, and the last four digits of their social security number. That’s right — not even the whole number. This is information that tons of people have about almost everybody. Employers, former employers, universities, high schools, the postal service, the college board, and lots of others have this info about me.

I said, “But anyone with the information on this card” — gesturing to my absentee ballot request form — “would be able to just show up and claim to be me? And no one would challenge that?”

She looked at me as though I’d expressed concern that the ballot-boxes weren’t sufficiently elf-proofed. After an exasperated hand-on-hip-eyeroll-sigh, she demanded, “Now, who would ever go to that much trouble?” and huffed away. My ID never left my pocket.

(Disclaimer: this is probably not a new development by any means. I have never voted absentee before, so I have no idea how long this opportunity for election fraud has been available, and I can only speculate that it’s been a good many years. I also can’t guarantee the efficacy of voting a bajillion times for your chosen candidate, because it seems likely that the number of people on each side of any given controversial ballot issue who carry out this kind of fraud would probably be evenly distributed enough to cancel each other out. And then there’s also the question of whether absentee votes are even counted, or whether anyone’s votes are counted, or whether the word ‘counting’ even applies at all to election polling at all anymore. )

Conventionally, a storage medium will report its life expectancy in terms of MTBF, or Mean Time Between Failures. This is often measured in hours. However, it’s not always this simple. Usage patterns and environmental characteristics take a heavy toll on how long our storage devices last.

One fun experiment I unintentionally tried this afternoon helps provide one data point that goes above and beyond our classical MTBF estimate, and into the realm of — shall we say — aquatic endurance?

Several months ago, I purchased a SanDisk 1.0GB Cruzer Micro USB flash drive. I used this as spill-over when I took too many videos without flushing the data off of my camera while I was in Utah. Since I didn’t have a personal computer, and only had limited computer access, the best I could do was shuffle data between various solid-state devices. So this device has been filled to capacity a couple times, and has been completely erased a couple times, and has had various data-shuffling jobs in between for the past 9 months or so. Despite being dropped, being X-Rayed at SLC Airport, and being kept in pockets for long periods of time in various weather extremes, it has held up like a champ. I’ve not lost anything, nor have I had any problems shuffling data between my laptops and desktops, as well as other machines.

This experiment, however, was above and beyond the typical environmental exposure these devices normally take. Today, my little USB drive got to take a swim through our Frigidaire Washer and then through our Whirlpool Dryer. For what it’s worth, the Washer is a sideways one, so it uses less water. This might have been the show-stopper in disguise.

The reason this all happened is because I normally hold all of my belongings in my pockets. That’s what they’re there for, after all. Because I was shuffling data around last week, I must have left it in one of my pockets.

Upon finding myself nearly out of clothes for the week, I opted to do laundry. My work clothes were especially dirty (landscaping tends to get lots of dirt on your hands and clothes) so I opted to wash with the Heavy Wash Cycle, which takes about 25-30 minutes, to get my clothes all clean and ready for the coming work week. It was a fairly large load; several (4) pairs of jeans and many (5) shirts. No socks.

After washing, I like to get my clothes into the dryer as soon as possible to avoid the mildew smell. I’ve never had much faith in the “automatic” setting on dryers, so I put all the clothes in for 60 minutes. Since I had more than 2 pairs of jeans in there, I also extended the dryer time an additional 20 minutes once the first 60 expired because my jeans like to hold irrationally large quantities of water and are never dry after a mere 60 minutes of high heat. After this duration, I removed my clothes, and discovered my flash drive sitting comfortably on the bottom of the dryer cylinder. This, of course, made me a bit downhearted. Cellphones can’t endure this kind of rough treatment. Palm Pilots can’t either. I wouldn’t dare try it on a camera, CD player, or Social Security Card either. From past experience, things were looking grim for this little data carrier.

As with any storage medium loss, the first thoughts through my head were “What did I put on that device that isn’t backed up somewhere else?” Thankfully, I couldn’t remember anything. This was in part because I haven’t explored it much in a long time, making me likely to forget. It’s always easier to lose data if you can’t remember what it was anyway.

Deciding to test it out and see what I could salvage, I decided to plug it into my laptop and see what would happen. I was partially expecting it to cause my laptop to reboot; I’ve seen computers where shorting the USB +5V and Ground pins acts as a poor man’s reset switch. If that didn’t happen (I’ve also seen where my MacBook is engineered to be at least a little more resilient than that), I figured it’d leave some fun console messages, do nothing, or have tons of data errors.

Much to my surprise, the disk lit up when inserted. It also blinked a couple times, characteristic of OS auto-mounting. This was good so far. The mounted volume showed up on my desktop, and lo-and-behold, all the data was there, intact. Currently, I have about 450MB of data on it. Disk Utility didn’t find any File System problems, and inspection using Finder didn’t either. The pictures show up fine, the MP3’s sound fine, and all the source code is intact. Since JPEGs and MP3s will be essentially useless if even a few bits are toasted, I find these to be handy metrics in the event of suspected data corruption.

So, when looking for devices that retain data above and beyond the call of normal duty, look no further. This little Cruzer took a licking, and has kept on ticking.

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…

But this morning he called me with a rather odd problem:

“I hooked up my Treo and started syncing it, then walked away for a few minutes. When I returned, the screen was covered with a bunch of squares, and I can’t do anything.”

He took a few photos with his cellphone camera and emailed them to me (click for full-size):

(You can see bits of the menu-bar scattered around the screen, and it looks like Missing Sync had launched iPhoto. Possibly related?)

I talked him through a few tests. He was able to see the mouse cursor and move the mouse, but clicking didn’t cause any apparent response. He could activate Dashboard — Dashboard itself looked fine, and the checkerboard showed through in the background. He then tapped the power button, and the “Are you sure you want to shut down your computer now?” dialog appeared, but it was scrambled and the buttons didn’t work.

I instructed him to power it off by holding the power button down. Since rebooting, it’s been working fine.

*Confused.*

I googled it a bit but wasn’t able to find any clear reports of this happening to other people.