Up until now I’ve used a collection of Smart Playlists which take into account my ratings, when I last listened to songs and a whole bunch of other information. At the last count, I had over 70 Smart Playlists feeding into each other to generate the playlists which finally get Synced over to my iPhone.

But there was something missing. Whilst I could generate playlists based on the mid-90s simplicity of the “Genre” tag, that tag is by design only able to identify one piece of information. So I wouldn’t be able to find, for example, all tracks in my collection that are “rock”, “funny” and performed by a “female”. And even if I could, I wouldn’t want to go and tag 40,000 tracks by hand. That way madness lies.

It turns out there’s a fairly simple solution to this – last.fm allows users to tag any and all tracks it knows about, and it keeps track of how many times each track has been tagged with each tag. So, it’s entirely possible to grab the top 15 tags for each track in my collection, add that data to my tracks somehow, and then query that.

The somehow turns out to be pretty simple too – the ID3 “comment” field is there for the taking, and by design is expected to be larger than any other field. Excellent. So that’s the “where to store” sorted, now how about “how to store so that the data is queryable”?

For this I took a trick out of Brian Suda’s book. A couple of years back I took a look at how he’d written his microformats parser using XSLT to be able to check for classes an element may or may not have – the trick being to wrap strings of classes with a space at the beginning and end so that every class always had spaces surrounding it. I used the same trick for storing my tag data, also wrapping it in a ‘lfm’ square bracketed enclosure to separate it from any other data in the comment.

So, the data I saved in the comment looked a little something like this:

[lfm: tag1 tag2 tag23 tag3 ]

You’re probably starting to see why wrapping in spaces is important now. Because iTunes’ Smart Playlist system can only perform simple string matching (Apple doesn’t seem to like regexes – AppleScript can’t do them natively either), you need some way of targetting the beginning and end of tags. Without those spaces, a query of “Comments contains 'tag2'” would return you both tag2 and tag23, which no-one wants. By requesting “Comments contains ' tag2 '” instead (note the extra spaces) you end up just being given tag2.

All this thinking is packaged up into a couple of scripts (though obviously take the latest code if you want to actually use it yourself) I wrote a couple of days ago that takes a given playlist from your iTunes library, asks last.fm for tags for each of the songs in that playlist, and then adds that data to the library using AppleScript.

Problems?

There are, unfortunately, a couple of issues with the script at the moment. First off, because last.fm allows anything and everything to be given as a tag, they can contain characters that need to be normalised out. Right now I’m doing that very simply (spaces to dashes mostly), but I should revisit the code and harden that normalisation – I’ve seen tagging bail out a couple of times because of unexpected data.

Next up, the fact that last.fm allows tags to be incredibly long coupled with the fact that under ID3 v2.x the comments field can only be 256 characters long means that it’s possible to run into issues with tagsets being too long to fit into the comments field. Add that to the fact that some songs in my collection legitimately contain comments already and that I want to add tags non-destructively, and we’re ending up with not much space for tags. So, an improvement that I’m planning on making to the script is to make sure that tags try to take up no more than the space that’s legitimately available to them.

The final issue that I’ve been having lives with last.fm’s track.getTopTags API method. Unfortunately at present the track.getTopTags API method does not perform any auto-correction of track names, which means that if you try to get the tags for something that does get auto-corrected by the system then you end up with the tags for the uncorrected track name. A subtle distinction, but it probably means that we end up with unmaintained tags that haven’t been touched for the year or so since auto-correction was turned on. A possible solution here if last.fm choose not to “fix” this behaviour (it could be argued that this is correct behaviour) would be to make a request out to Musicbrainz to get an ID for the track and then pass that into track.getTopTags instead. But that seems like a whole bunch of extra work for a not massive gain.

The final Smart Playlist

So, what about that Smart Playlist? After all, that’s the thing that all this work was done for.

In iTunes, select File, New Smart Playlist, and then enter the following:

Match all of the following rules:
    Comments contains ' female '
    Comments contains ' rock ' ...
    any of the following rules:
        Comments contains ' comedy '
        Comments contains ' funny '

This cunning playlist uses a Smart Playlist feature I wasn’t aware of until yesterday – rule groups. Up until now, I’d been pulling in other Smart Playlists as sources to perform the same job.

To create a new rule group in a Smart Playlist, simply click an ellipsis button in the Smart Playlist interface, rather than clicking on the plus button.

Essentially what these rule groups give you is the ability to nest rulesets, and generate very complex playlists that don’t have half their rules hidden in external playlists. In the playlist above we’re simply asking for all tracks tagged with “female”, “rock” and either “funny” or “comedy”. So essentially “female comedy rock”. At present this playlist returns me no items from my collection, but not everything’s been tagged yet. I’m hopeful.

The first thing to be aware of is that if Safari can display something on a webpage, then Dashboard can display it as well. If you visit a page in Safari and right-click somewhere on the background of the page then you should see a menu item titled Open in Dashboard.... If you select this then you’ll be able to drag to select an area of the page to turn into a dashboard widget. Click the Add button at the top of the window once you’re done, and you’ll magically have created a widget. Now, any time you open up your Dashboard that widget will be reloaded and you’ll see fresh data.

So, that’s how we’ll display the playlist as a Dashboard Widget – we’ll create a webpage that contains the data and then use that as the widget.

If you read the last entry, you’ll know that I like to use AppleScript as a quick glue language on my Mac. It’s pretty easy to use (once you know what you’re doing), and you can hook into many of the apps you use on a day to day basis and do interesting things with them. So, it should be no surprise to hear that I’ll be using AppleScript to get the playlist data out of iTunes. Given that I’ll be displaying this data on a webpage though I’ll be using PHP (because it’s what I know) to write a quick and dirty page that displays the data that the AppleScript provides.

The AppleScript is a little more involved than the one liners we used last time. We need to grab the current playlist and then grab information about its UID, Title, Artist and Album, and before finally finding out what the currently playing track is. Here’s how we do that.

set tracks_list to {}

tell application "iTunes"
    tell current playlist
        tell tracks
            set tracks_list to get {persistent ID, name, artist, album}
        end tell
    end tell

    set tracks_list to tracks_list  {persistent ID of current track}
end tell

get tracks_list

In this script we first we create an empty list to put all our data in, then we add lists of track IDs, names, artists and albums to it, then we add a single item of the currently playing track’s ID. It’s not the most elegant of data structures to use once we get to play with it in PHP, but it’ll do. Running this from the commandline using osascript -s s playlist.scpt (the -s s means “print the output in a recompilable form”) gives us something like the following (respaced for clarity):

{
    {
        "0D7D716D221B623B", 
        "688E193B9F7F7EE3", 
        "05BFA94137C9691F"
    }, 
    {
        "Fashion Is Danger", 
        "Fabulous", 
        "Never Gonna Give You Up"
    }, 
    {
        "Flight of the Conchords", 
        "High School Musical Cast", 
        "Rick Astley"
    }, 
    {
        "I Told You I Was Freaky", 
        "High School Musical 2", 
        "Fantastic 80s"
    }, 
    "688E193B9F7F7EE3"
}

Now that we have a data structure, we can actually do something with it in PHP. Unfortunately, as far as I’m aware there’s nothing built into PHP that’ll read this structure. Fortunately though, this structure is pretty damn close to JSON. If we were to replace the twiddly brackets with square ones then PHP’s json_decode would return a data structure and we could do something with the data. Hooray. It’s a hack, but it works, and it’s what I did. A simple str_replace later and I had data. You can see the code, such as it is, in my github repository.

The eagle eyed amongst you will notice that I’m not directly calling osascript from my PHP script though, and am instead going through an intermediary shell script that nukes DYLD_LIBRARY_PATH before running the AppleScript. The reason for this is that on the machine I’m running the script on I’m using MAMP for my web stack, and that does funny things with DYLD_LIBRARY_PATH under Snow Leopard apparently. So, I have to nuke it.

And that’s all there is to it. Visit the webpage you’ve created to display the data, let it show you what’s playing and then turn it into a dashboard component using Safari. I get to control iTunes on a remote machine and I don’t have to keep a VNC connection on it. This makes me happy.

My situation is that my iTunes music library is stored on my MacMini that lives in my living room (connected to and powering my TV experience). However, most of the time I spend using my MacBook Pro, which spends most of its time in the office upstairs a fair way away from the MacMini. Because I spend most of my time at the laptop, it’s nice to have music available for me to listen to on it. Of course, if I just wanted to listen to music then this would be a very short blog post – I could use iTunes to share the library from the MacMini and listen to the music upstairs, or I could use Spotify or Last.fm. The problem with these as solutions are that I make heavy use of Smart and Genius Playlists in iTunes to generate playlists of music to listen to. Using iTunes’ sharing feature doesn’t allow me to rate tracks in the originating library (even with iTunes 9′s “Home Sharing” feature), and it also doesn’t generate extra playcount in the originating library for the things I listen to. This means my Smart Playlists don’t update in the expected way, and I become a sad panda. Likewise, Genius Playlists don’t work in a usable way when using a shared library, so this doesn’t really work for me.

What I wanted was a way to play my music using the MacMini downstairs, but have the music erupt from the speakers connected to my MacBook Pro. As it turns out, there’s an app for that – Airfoil. This lovely application hijacks audio from one device and sends it out across the network to multiple other devices of your choice, all in sync. So, immediately I was able to use OSX’s Screen Sharing app to connect to my MacMini, start some music playing in iTunes and then have Airfoil pipe it out to my MacBook Pro. It was a solution that was sheer elegance in its simplicity. Yes, you have to wait a second or so after pressing play before you hear anything come out of your speakers, but that’s down to Airfoil making sure all your devices are in sync before it starts to do anything. All in all, it’s brilliant. It costs $25, but that’s a small price to pay for this functionality for me.

The only problem is that in playing music on a different computer than the one you’re on, you’re playing music on a different computer than the one you’re on. So various things, like media keys on your keyboard don’t work in the way you expect. So, whenever I was wanting to do simple things like pause my music I was having to go into Apple’s Screen Sharing app, log into the MacMini and then press the pause button in iTunes. Not ideal. So, I wrote a quick AppleScript in Apple’s Script Editor:

tell application "iTunes" of machine "eppc://macmini-2.local" to playpause

Yup, that’s a really simple AppleScript. Something I wasn’t aware of until a couple of days ago is that it’s possible to run AppleScript that runs AppleScript on a different machine. All you have to do is go into System Preferences, open the Sharing panel, and enable Remote Apple Events. The first time you try to run an event on the remote machine you’ll be asked to enter your credentials on the local machine, which you can save to your keychain for auto-use in the future. Now, if I run that AppleScript then iTunes on the remote machine will toggle its play state, and consequently on my local machine. Awesome.

It’s just as easy to write other scripts as well. For example, to advance to the next track, just change playpause to play (next track).

But we’re still not controlling iTunes on the remote machine with just a keypress. If you’ve got something like Quicksilver installed on your machine then you should be able to simply hook the script up to a key combination of your choice. I don’t currently have Quicksilver installed on this machine (and wasn’t about to install it just for this), so I had to find another alternative. What I’m currently using is FastScripts Lite, a free app that adds an icon to your menubar that contains menu items for any AppleScripts you put in a certain directory. The nice thing about FastScripts is that it also allows you to enter a keypress combo for any of these scripts by going into its Preferences pane and double clicking on the Shortcut field next to the relevant script. I’ve got playpause bound to ctrl-up, next track to ctrl-right and previous track to (you guessed it) ctrl-left. Now I can easily change what I’m listening to with a quick keypress, and I’m happy.

Well, I’m almost happy. I still need to have Screen Sharing open so that I can see what’s actually in the playlist that I’m listening to. There’s a solution to that as well though. All I needed do was create a script that calls some AppleScript on the MacMini, grabs the current playlist info and then outputs it into a web page. I could then use this page as the basis of a Dashboard widget and I’d only ever have to press F12 to see my current playlist. And that’s what I did. To find out how I did it though, you’ll have to read the next post!