Allocate a player_control object where needed, and pass it around.
Each "client" object is associated with a "player_control" instance.

This prepares multi-player support.

The check was meant to fix an assertion failure, but it was the wrong
way around.  This broke cross-fading most of the time.

Workaround for an assertion failure.

Rename the function to playlist_song_started(), which gets only called
if the song has actually started.

With single+repeat enabled, it is expected that MPD repeats the
current song over andd over.  With random mode also enabled, this
didn't work, because the song order was shuffled internally.  This
patch adds a special check for this case.

After we've been hit by Large File Support problems several times in
the past week (which only occur on 32 bit platforms, which I don't
have), this is yet another attempt to fix the issue.

No more CD player emulation.  The current behaviour of "previous" is
difficult for a client to predict, because it does not definitely know
the current position within the song.  If a client wants to restart
the current song, it can always send "playid".

Renamed all playlist functions to non-CamelCase.

To determine whether to rewind the current song or to go to the
previous song, use a GTimer instead of manually diffing time(NULL).

Consume mode removes each song played

When single mode is enabled, after current song it stops playback,
or it replay same song if repeat mode is activated.

The smartstop feature is a way to tell mpd to stop playing after
current song.
This patche provides:
- 'state' command returns 'smartstop' state (1 or 0)
- 'smartstop' can activate or not the smartstop state
- when song is terminated, mpd stops playing and smartstop is set to 0

This updates the copyright header to all be the same, which is
pretty much an update of where to mail request for a copy of the GPL
and the years of the MPD project. This also puts all committers under
'The Music Player Project' umbrella. These entries should go
individually in the AUTHORS file, for consistancy.

When MPD is not playing, it may still remember which is the "current"
song.  When you switch to "random" mode, MPD will always start playing
exactly this song.  This defies the goal of "random" mode a little.
Clear the "current" song when MPD is not playing during the "random"
mode switch.

Check if the "current+1" position is actually valid.

In random mode, this patch allows clients to see the "next song" in
the queue.

Removed the explicit "playlist:" prefix from all log messages.

Pass constant playlist objects to functions which do not modify it.

Moved functions for playlist editing (append, delete, shuffle, move)
to playlist_edit.c.

Moved handlers for control commands (play, stop, next, prev) to
playlist_control.c.

Don't call syncPlaylistWithQueue() in nextSongInPlaylist() and
previousSongInPlaylist().  This is a relic from the time when there
was no event, and was a workaround to the timing problem.

Export the "g_playlist" variable, and pass it to all playlist
functions.  This way, we can split playlist.c easier into separate
parts.  The code which initializes the singleton variable is moved to
playlist_global.c.

Moved everything related to saving or loading the playlist from/to the
state file to playlist_state.c.

Before every operation which modifies the playlist, remember a pointer
to the song struct.  After the modification, determine the "next song"
again, and if it differs, dequeue and queue the new song.

This removes a lot of complexity from the playlist update code, and
makes it more robust.

This fixes an assertion failure: when the last song in the playlist
was playing, and you deleted it, MPD aborted.

Both are unused.

This function shuffles the last song of a range.  This is used by
addSongToPlaylist().

Don't declare and export variables specific to stored playlists in
playlist.c/playlist.h.

Now playlist.c does not contain any protocol specific code anymore.

No CamelCase and no typedefs.