You’ll also need to define a process lock to protect access to this hash table like this:

    1. (defparameter *playlists-lock* (make-process-lock :name "playlists-lock"))

    Then define a function that looks up a playlist given an ID, creating a new playlist object if necessary and using with-process-lock to ensure that only one thread at a time manipulates the hash table.1

    1. (defun lookup-playlist (id)
    2.   (with-process-lock (*playlists-lock*)
    3.     (or (gethash id *playlists*)
    4.         (setf (gethash id *playlists*) (make-instance 'playlist :id id)))))

    Then you can implement find-song-source on top of that function and another, playlist-id, that takes an AllegroServe request object and returns the appropriate playlist identifier. The find-song-source function is also where you grab the User-Agent string out of the request object and stash it in the playlist object.

    The trick, then, is how you implement playlist-id, the function that extracts the identifier from the request object. You have a couple options, each with different implications for the user interface. You can pull whatever information you want out of the request object, but however you decide to identify the client, you need some way for the user of the Web interface to get hooked up to the right playlist.

    1. (defun playlist-id (request)
    2.   (ipaddr-to-dotted (remote-host (request-socket request))))

    The function request-socket is part of AllegroServe, while remote-host and ipaddr-to-dotted are part of Allegro’s socket library.

    To make a playlist usable as a song source by the Shoutcast server, you need to define methods on current-song, still-current-p, and maybe-move-to-next-song that specialize their source parameter on playlist. The current-song method is already taken care of: by defining the accessor current-song on the eponymous slot, you automatically got a current-song method specialized on playlist that returns the value of that slot. However, to make accesses to the playlist thread safe, you need to lock the playlist before accessing the current-song slot. In this case, the easiest way is to define an :around method like the following:

    2.   (with-playlist-locked (playlist) (call-next-method)))

    Implementing still-current-p is also quite simple, assuming you can be sure that current-song gets updated with a new song object only when the current song actually changes. Again, you need to acquire the process lock to ensure you get a consistent view of the playlist‘s state.

    The trick, then, is to make sure the current-song slot gets updated at the right times. However, the current song can change in a number of ways. The obvious one is when the Shoutcast server calls maybe-move-to-next-song. But it can also change when songs are added to the playlist, when the Shoutcast server has run out of songs, or even if the playlist’s repeat mode is changed.

    1. (defun update-current-if-necessary (playlist)
    2.   (unless (equal (file (current-song playlist))
    3.                  (file-for-current-idx playlist))
    4.     (reset-current-song playlist)))
    6.   (if (at-end-p playlist)
    7.     nil
    8.     (column-value (nth-row (current-idx playlist) (songs-table playlist)) :file)))
    10. (defun at-end-p (playlist)
    11.   (>= (current-idx playlist) (table-size (songs-table playlist))))

    You don’t need to add locking to these functions since they’ll be called only from functions that will take care of locking the playlist first.

    The function reset-current-song introduces one more wrinkle: because you want the playlist to provide an endless stream of MP3s to the client, you don’t want to ever set current-song to **NIL**. Instead, when a playlist runs out of songs to play—when songs-table is empty or after the last song has been played and repeat is set to :none--then you need to set to a special song whose file is an MP3 of silence3 and whose title explains why no music is playing. Here’s some code to define two parameters, *empty-playlist-song* and *end-of-playlist-song*, each set to a song with the file named by *silence-mp3* as their file and an appropriate title:

    1. (defparameter *silence-mp3* ...)
    3. (defun make-silent-song (title &optional (file *silence-mp3*))
    4.   (make-instance
    5.    'song 
    6.    :file file
    7.    :title title
    8.    :id3-size (if (id3-p file) (size (read-id3 file)) 0)))
    9. (defparameter *empty-playlist-song* (make-silent-song "Playlist empty."))
    11. (defparameter *end-of-playlist-song* (make-silent-song "At end of playlist."))

    reset-current-song uses these parameters when the current-idx doesn’t point to a row in songs-table. Otherwise, it sets current-song to a song object representing the current row.

    Now, at last, you can implement the method on maybe-move-to-next-song that moves current-idx to its next value, based on the playlist’s repeat mode, and then calls update-current-if-necessary. You don’t change current-idx when it’s already at the end of the playlist because you want it to keep its current value, so it’ll point at the next song you add to the playlist. This function must lock the playlist before manipulating it since it’s called by the Shoutcast server code, which doesn’t do any locking.

    1. (defmethod maybe-move-to-next-song (song (playlist playlist))
    2.   (with-playlist-locked (playlist)
    3.     (when (still-current-p song playlist)
    4.       (unless (at-end-p playlist)
    5.         (ecase (repeat playlist)
    6.           (:song) ; nothing changes
    7.           (:none (incf (current-idx playlist)))
    8.           (:all  (setf (current-idx playlist)
    9.                        (mod (1+ (current-idx playlist))
    11.       (update-current-if-necessary playlist))))