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.

There were only two possible states: STOP and PLAY.  The code looks a
lot easier if we use a bool instead.  Move the variable into the
playlist struct.

The function shuffles the virtual order of songs, but does not move
them physically.  This is used in random mode.

The new function replaces playlist.c's randomizeOrder() function,
which was aware of playlist.current and playlist.queued.  The latter
is always -1 anyway, and the former as preserved by the caller, by
converting playlist.current to a position, and then back to an order
number.

Add a "changed" check to setPlaylistRepeatStatus(): when the new
repeat mode is the same as the old one, don't do anything at all.  No
more checks, no "idle" event.

When the random mode is toggled, MPD did not clear the queue.  Because
of this, MPD continued with the next (random or non-random) song
according to the previous mode.  Clear the queued song to fix that.

Merged duplicate code from queueNextSongInPlaylist().

Attempt to untie the playlist.c knot: moved the playlist storage code
to queue.c, struct queue.

Check for current>=0, not queued>=0.

The function moveSongInPlaylist() attempted to read the position of
the current song, even if it was -1.  Check that first.  The same bug
was in shufflePlaylist().

It is possible that playlist.current is reset before the TAG event
handler playlist_tag_event() is called.  Convert the assertion into a
run-time check.

Don't attempt to restart the player if it was stopped, but there were
still songs left on the playlist.  This looks like it has been a
workaround for a bug which has been fixed long time ago.

Don't assign the result of getPlayerError() to an integer.

Use g_free() consistently with g_malloc().  Don't clear the pointers
after freeing them.

Simplify some code by using config_get_positive(), instead of doing
manual parsing and validation each time.

The "TAG" event is emitted by the player thread when the current
song's tag has changed.  Split this event from "PLAYLIST" and make it
a separate callback, which is more efficient.

Renamed functions, types, variables.

getBoolConfigParam() returns an int.  It is not possible to check for
CONF_BOOL_UNSET after it has been assigned to a bool; use a temporary
int value for that.

When a song file is deleted during database update, all pointers to it
must be removed from the playlist.  The "for" loop in
deleteASongFromPlaylist() did not deal with multiple copies of the
deleted song properly, and left instances of the (to-be-invalidated)
pointer in.  Fix this by reversing the loop.

MPD's shuffling algorithm was not implemented well: it considers songs
which were already swapped, making it somewhat non-random.

Fix the Fisher-Yates shuffle algorithm by passing the proper bounds to
the PRNG.

A song index cannot be negative.  Also require the second parameter to
be valid.

In a range "start:end", "end" itself should not be included.  Use the
same semantics as other languages implementing ranges, e.g. Python.

Loosely based on a patch provided by lesion in bug #1766. The playlistinfo
command can now retrieve ranges of the playlist. The new argument indicates
which entry is the last one that will be displayed. The number of displayed
entries may be smaller than expected if the end of the playlist is reached.

Previous usage:
playlistinfo [start]

New usage:
playlistinfo [start[:end]]

Don't call command_error() if loading a song from the playlist fails.
This may result in assertion failures, since command_error() may be
called more than once.

For internal checks (i.e. not in command.c), we need to check whether
an URI is in the databse, in the local file system or a remote URI
with a scheme.

If the state file cannot be read, for whatever reason, don't abort
MPD.  The state file isn't _that_ important.