In the first part of this series I explained how to build and configure the Music Player Daemon (MPD) for use with Live365. In this installment I’ll describe how to send the song metadata (Title, Artist, Album). This is a requirement for ‘live’ mode broadcasters; if you do not send this data your station will not be listed in the directory.

When you run a Live365 station in ‘basic’ mode they pull the song metadata directly from the ID3 tags in your MP3 files. Most MP3 streams include this info. within the stream itself so that it can be displayed by the player software. Live365 does not extract this data from the stream you feed to them. Live365 provides an API (application program interface) that allows you to feed the data to them separate from the music stream.

Feeding the Metadata

The tricky bit is synchronizing the metadata feed with the music feed. Ideally, this would be done from within the music player directly but unfortunately MPD has no ability to do this; we’ll have to write something ourselves. The process will involve extracting the current track information from MPD and then relaying that to Live365 via the ‘add-song’ API. I’ve written a PERL script to handle this; you can find the complete script here.

You’ll need a few PERL modules to accomplish the task at hand (all are available via CPAN):

Audio::MPD – This is the interface to the MPD player
URI::Escape – Encodes text suitable for inclusion in a URL
Data::Dumper – Useful for debugging

Dissect the Code (please, be kind)

First off, let’s get the necessary modules called in:

#!/usr/bin/perl -w
#----------------------------------------------
# MPDFeed - Update Live365 with track info as it is
#           played by MPD.
#
# 2009-dec-6 - TimC v0.1
#       First Go
#       TODO: Need to check return values from Login and AddSong and act appropriately.
#----------------------------------------------
use Audio::MPD;
use LWP;

use URI::Escape;

use Data::Dumper;

use strict;

Next, we’ll define some global variables and constants:

#-------------------
# G L O B A L S
#-------------------
my $MPDHOST = 'localhost';	# hostname or IP of machine running MPD
my $VOLUME = 90;        # Playback volume
my $REPEAT = 1;         # repeat is ACTIVE
my $RANDOM = 1;         # random is ACTIVE
my $XFADE = 5;          # crossfade time is 5s

my $mpd;

my $L365_LOGIN_URI = 'http://www.live365.com/cgi-bin/api_login.cgi';
my $L365_NP_URI = 'http://www.live365.com/cgi-bin/add_song.cgi';
my $L365_USER = 'YOUR_LIVE365_USERNAME';
my $L365_PW = 'YOUR_LIVE365_PASSWORD';

my $DEBUG = 0;

my $browser;            # LWP::UserAgent;
my $session_id;         # Live365 API login session ID

You’ll need to update $L365_USER and $L365_PW appropriatly for your Live365 account. These are the same values you use when you login directly to the Live365 website.

If you wish to see the nitty-gritty details of the scripts operation you can enable the DEBUG flag by setting it to 1;

Let’s look at the song info. update routine:

#---------------------
sub Live365NowPlaying($$$$$)
#---------------------
{
my $title = shift;
my $artist = shift;
my $album = shift;
my $duration = shift;
my $filename = shift;

my $url = '';
my $resp = '';

  unless ($browser) {
   $browser = LWP::UserAgent->new;
   $browser->agent("MPDFeed/0.1 ");
  }

  if ($DEBUG) {
    print 'Tit: [' . $title . ']  Art:[' . $artist . ']  Alb:[' . $album . ']  Dur:[' . $duration . ']  FN:[' . $filename . "]\n";
  }

  $url = $L365_NP_URI . '?version=2&charset=UTF-8'. '&member_name=' . $L365_USER . '&password=' . $L365_PW;
  if ($title) { $url .= '&title=' . uri_escape($title); }
  if ($artist) { $url .= '&artist=' . uri_escape($artist); }
  if ($album) { $url .= '&album=' . uri_escape($album); }
  if ($filename) { $url .= '&fileName=' . uri_escape($filename); }
  if ($duration) { $url .= '&seconds=' . $duration; } else { $url .= '&seconds=120'; }

  if ($DEBUG) { print 'L365: [' . $url . "]\n"; }

  $resp = $browser->get($url);
  if ($DEBUG) { print 'L365 resp:[' . $resp->content . "]\n"; }
  die "Couldn't get $url". ':' . $resp->status_line . "\n" unless $resp->is_success;

  if ($DEBUG) { print 'Headers:[ ' . $resp->headers_as_string() . "]\n"; }

  return 1;
}

First, it creates $browser object if necessary. It then assembles the API URL from the available info. It starts with the basic API URL and then adds on the track title, artist, album, filename and duration. The duration data is important as it is provided to the Live365 listener’s player to tell it when to update the current song display (album art, title, etc.). If the duration data isn’t available I send along a default of 2 minutes so that the player will check back for the next track.

The importance of being Ernest (who the heck is ‘Ernest’ anyway?)

It is important to supply track title, artist and album info to Live365 as this is what they use to determine if your stream is DMCA compliant. If any of these fields are missing or incorrect the result may be the dreaded ‘de-listing’ notice. We get this data from MPD a bit later in the script, but MPD gets it from the ID3 tags within the audio files so it is vitally important that you review and correct these tags before you begin streaming.

I’m going to skip describing the DisplayStatus() routine — it’s operation is obvious.

Let’s jump down to the mainline of the script:

#-------------------
# M A I N
#-------------------
my $ver = '';
my $mpd_status;
my $mpd_time;
my $mpd_song;
my $time_remain;
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst);

  $mpd = Audio::MPD->new(host=>$MPDHOST);
  unless ($mpd) { die "*E* Unable to connect to MPD running on $MPDHOST.\n"; }

  $ver = $mpd->version();

  print "MPD Version is: [$ver]\n";

# - set the correct volume
  $mpd->volume($VOLUME);

# - set the playback parms
  $mpd->repeat($REPEAT);

# - set the 'shuffle' mode
  $mpd->random($RANDOM);

# - set the crossfade parms
  $mpd->fade($XFADE);

# - Get the current status
  $mpd_status = $mpd->status();

  DisplayStatus($mpd_status);

Loopty-Loop

We connect to the MPD daemon and then set several playback options. The ‘volume’ doesn’t impact the stream but it does set the level for local playback. We then grab the current status and display it on the console. We then enter into an endless loop:

# - Loop forever
  while (1) {
    $mpd_status = $mpd->status();
    $mpd_song = $mpd->song();
    ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=localtime(time);
    printf "%4d-%02d-%02d %02d:%02d:%02d: ",$year+1900,$mon+1,$mday,$hour,$min,$sec;

    if ($mpd_status->state() eq 'play') {
      print "Playing: [" . $mpd_song->title() . "]:[" . $mpd_song->artist() . "]:[" . $mpd_song->album() . "]:[" . $mpd_song->file()
 . "]:[" . $mpd_status->audio() . "]\n";

      $mpd_time = $mpd_status->time();
      $time_remain = abs( $mpd_time->seconds_left() );          # abs() to avoid negative values
      if ($DEBUG) { print "time remaining: [" . $time_remain . "] seconds]\n"; }

      Live365NowPlaying($mpd_song->title(), $mpd_song->artist(), $mpd_song->album(), $time_remain, $mpd_song->file());

    } else {
      print "Player Stopped: Waiting 2 minutes...\n";
      $time_remain = 120;
    }

    sleep ($time_remain + 1);

    $mpd = Audio::MPD->new(host=>$MPDHOST);     # the damn thing doesn't maintain a connection -- DOH!
  }

Within the loop we grab the current player status and currently playing song data. If the stream is active (the daemon is in ‘play’ state) the current song, along with a timestamp is displayed on the console. We then pass the song data to the update routine for posting to Live365. The script then sleeps for the remainder of the current song.

If the stream is not active, the script simply waits 2 minutes before trying again.

Using this method we can run the script independently of the MPD daemon and it will automatically synchronize itself with the playback.

In the next installment I’ll describe the setup of your live station on Live365.

As always, you can drop questions into the comments or directly to me at dreamlandblues at frontierdigital dot com.

UPDATED 10-jan-10: Fixed the code line numbering.

I’ve run Dreamland Blues Radio, a streaming internet radio station, since 1997. In the beginning I used WinAmp + Shoutcast streaming server on a Windows 95 machine. As the station grew in popularity and my then boss began to notice the bandwidth utilization of the R&D lab outside business hours (rats!) I came to the realization that I needed a more stable and scalable platform; enter Live365.

Of course, back then it wasn’t called Live365 (bonus points for anyone who can tell me the original name) but I was invited to preview the beta of the service – I jumped at it. The original setup continued to use WinAmp with the Shoutcast plug-in but the feed was then sent to Live365 for audience distribution; what is now called a ‘Live’ stream.

Backgound & Design Goals

I’ll spare you the remainder of the history lesson but suffice to say that several years ago I abandoned the ‘Live’ approach and switched to a Basic stream. I was not happy about it but the situation at the time left little alternative. I’ve always wanted to return to Live ‘casting. Cross-fade to today…

While Windows does make for a decent enough end-user experience I consistently turn to Linux based system for automating tasks that do not require ‘carbon based processing’. Dreamland Blues is not a ‘live’ station in the sense that a human DJ does voice-overs, in fact my voice has never appeared on the station; the station’s goal has always been to maximize the music. This is a perfect fit for an automated solution.

My design goal for the new system was to match the functionality of my original Windows based station:

• Ability to feed Live365 including song metadata (Artist, Title, Album) updates.
• Freshly generated playlist daily. Drawn from a catalog of thousands of tracks the playlist generation system considered many factors; my rating of the track, popular rating of the track, how long it had been in the catalog, etc.. It must maintain DMCA compliance.
• Ability to create and schedule ‘special event’ playlists. Good examples of this are Holiday music or Artist specials. (Sadly, in my genre this usually means memorials for a recently passed artist)
• ‘Hands off’ operation. The entire system must be capable of running without human interaction for extended periods (weeks).

I’m going to cover only the first requirement in this post; the others will follow later.

Music Player Daemon (MPD)

I’ve chosen to use MPD (Music Player Daemon as the core media player for my station. It includes a network based control interface and a rich set of commands to control playback functions and playlist operation. Version 0.15 of MPD supports HTTP based streaming that is necessary to feed Live365’s Nanocaster. The one missing bit is the song metadata; MPD can feed it along with the stream in Shoutcast format but Live365 does not parse it. I have another solution for metadata that I’ll cover later.

MPD is included with many Linux distributions but being the geek that I am I choose to build it from source. As of this writing the current version is 0.15.6 and is available on SourceForge. You will find a list of dependencies here. For our purposes you need the ‘httpd’ Audio Output requirements. You’ll also need the items from the Audio Decoding / Encoding section that match the format of your existing audio files (flac, AAC, MP3, wav, etc.). One of the main benefits of using MPD is it’s ability to transcode (e.g. convert formats from FLAC to MP3) and convert sample rates. This eliminates the need to re-encode your existing library to match the bitrate, format and sample rate of your station stream. EPIC WIN!

mpdserver:~ # cd /usr/src/
mpdserver:/usr/src/ # wget http://downloads.sourceforge.net/project/musicpd/mpd/0.15.6/mpd-0.15.6.tar.gz
mpdserver:/usr/src/ # tar -zxvf mpd-0.15.6.tar.gz
mpdserver:/usr/src/ # cd /mpd-0.15.6
mpdserver:/usr/src/mpd-0.15.6/ # configure –enable-http
mpdserver:/usr/src/mpd-0.15.6/ # make
mpdserver:/usr/src/mpd-0.15.6/ # make install

MPD Configuration

Next, you’ll need to edit the MPD configuration file, /etc/mpd.conf. Change the ‘music_directory’ and ‘playlist_directory’ options to point to the directories where you store you music files and your playlists respectively.

The key change in the config. file is to add an ‘httpd’ entry in the audio_output section. Here is a sample:

audio_output {
    type        "httpd"
    name        "My Awesome Station"
    encoder     "lame"            # This is the MP3 encoder
    port        "8000"            # listen on this TCP port for connections
    bitrate     "56"              # in kbps
    format      "22050:16:2"      # sample rate:sample size:channels
}

You can also add a section for an ALSA or OSS device so that you may listen to the feed locally.

I also enabled the ReplayGain feature by these settings:

replaygain           "track"   # track|album
replaygain_preamp    "0"       # in dB
volume_normalization "yes"

MPD Startup and Testing

Once you’ve saved the changes you start MPD with this command:

mpdserver:/usr/src/mpd-0.15.6/ # mpd /etc/mpd.conf

MPD will automatically daemonize (move to the background) and open the control port to listen for commands. To stop the MPD daemon:

mpdserver:/usr/src/mpd-0.15.6/ # mpd –kill

MPD will automatically start playing the playlist that was active when it was last shutdown. If this is your first time starting MPD then it will sit idle until you load a playlist and start playback. You access these controls using one of the many MPD clients or simply telnet’ing to the control port:

mpdserver:/usr/src/mpd-0.15.6/ # telnet localhost 6600
OK MPD 0.15.0

For some reason, it identifies itself as v0.15.0 when in fact is running the v0.15.6 version. The documentation for the various commands is available here . We are interested in loading a playlist and starting playback.

mpdserver:/usr/src/mpd-0.15.6/ # telnet localhost 6600
OK MPD 0.15.0
load myplaylist
play
currentsong

The ‘currentsong’ command will display the details of the currently playing track (big surprise, eh?).

Now that your stream has started you can fire up your favorite stream player (VLC, iTunes, WinAmp) and listen to your stream from any computer on your network. The URL of the stream is: http://ip_address_of_mpd_machine:TCP_PORT. Using my example above on a machine with IP address 192.168.0.12 the URL would be:

http://192.168.0.12:8000

After a few seconds of buffering you should hear you stream – hurray!

This is only the start; to complete your Live365 feed you’ll need to send along the metadata for the songs as they are played. I’ll cover that in the next post.

If you have any questions just drop them in the comments below and I’ll address them inline.

No snappy headline this time…

I’ve got a list…  a list of legends that I want to see perform before they pass from this reality.  I’ve recently taken inventor of the electric guitar and modern recording techniques Les Paul — it was in a word, amazing.  I think I’m still grinning from that show.

In the summer of 2007 I saw Koko Taylor perform at the Lowell Summer Music Series.  Even at the ripe old age of 78 she could still belt out a tune.  Her band was tight and the lead guitar even managed to take the term ‘lick’ literally as he managed to ‘play’ his axe with his tongue!

I don’t think there is any doubt that Koko qualifies as a legend; her trademark song Wang Dang Doodle (written by Willie Dixion — yet another legend) has been covered by a diverse array of artists from Ted Nugent to Grateful Dead and PJ Harvey.

Her gravelly voice and powerful style were unmistakeable.  I’m very glad to have seen her before she shuffled off her mortal coil.

Time to update the list…

You can see my photos from this show on Flickr.