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.

"ls" is a bad name for a library which parses URIs.  We'll move the
rest of the "ls" library later.

This command shuffles a range of songs.

When MPD is stopped, but the last song is still the "current song",
and you delete it, playlist->current is not updated, and becomes an
invalid value.  Fix this by catching "!playlist->playing &&
playlist->current == (int)songOrder".

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.

Replaced several wrapper functions from playlist.c, and make command.c
use the queue print functions directly.

To allow code outside playlist.c to access the "queue" object,
provide a function which returns a const pointer.

No typedefs.

Moved the 2 remaining global variables into the playlist struct.

When the playlist was loaded from the state file, the order numbers
were the same as the positions.  In random mode, we need to shuffle
the queue order.  To accomplish that, call setPlaylistRandomStatus()
at the end of readPlaylistState(), and do a fresh shuffle.

song_id_to_position() is only a wrapper for queue_id_to_position().

When MPD is not playing while in random mode, and the client issues
the "clear" command, MPD crashes in stopPlaylist(), or more exactly,
in queue_order_to_position(-1).  Exit from stopPlaylist() if MPD isn't
playing.

Create a new library which saves/loads the queue to/from the state
file.

PlaylistInfo() (notice the capital 'P') sends a stored playlist to the
client.  Move it to a separate library, where all the code which glues
the playlist and the MPD protocol together will live.

Moved protocol printing functions which operate on the queue to
queue_print.c.

The LocateTagItem objects are not modified.

swapSongs() is only a wrapper for queue_swap().

When you delete a song from the playlist which was paused, MPD forgot
that it was paused and started playing the next song.

The playlist.c source is currently quite hard to understand.  I have
managed to wrap my head around it, and this patch attempts to explain
it to the next guy.

The function playPlaylistIfPlayerStopped() is only called when the
player thread is stopped.  Converted that runtime check into an
assertion, and remove one indent level.

One of the previous patches removed the "random" mode check from
nextSongInPlaylist(), which caused a shuffle whenever MPD wrapped to
the first song in "repeat" mode.  Re-add that "random" check.

In playPlaylist(), the second "song==-1 && playing" check can never be
reached, because at this point, the function has already returned
(after unpausing).

All callers pass false.  Don't bother to collect that parameter.

When a song is deleted, start playing the next song immediately,
within deleteFromPlaylist().  This allows us to remove the ugly
playlist_noGoToNext flag, and the currentSongInPlaylist() function.

By calling queue_next_order() before playlist.current is invalidated
(by the deletion of a song), we get more robust results, and the code
becomes a little bit easier.  incrPlaylistCurrent() is unused now, and
can be removed.

Remove one indent level by returning diretly after the check.  This
makes the function more readable.