Moved the 2 remaining global variables into the playlist struct.

alternative settings must be set before the file
is loaded, otherwise they won't be respected.

Argument cmd of function command_available() is not used if mpd was
configured without sqlite.

In the return value of the "commands" command, don't list the
"sticker" command if no sticker file is configured.

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.

Removed unused includes.

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.

This patch fixes a regression introduced by commit aa9ffc.

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().

Added several comments.

Move everything which belongs together into one common struct.  This
simplifies the implementation of several queue operations.

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().

Pass const pointers where no writes are performed.

The null plugin synchronizes the playback so it will happen in real
time.  This patch adds a configuration option which disables this: the
playback will then be as fast as possible.  This can be useful to
profile MPD.

Free memory in the finish() method to make valgrind happy.

Renamed functions and variables.

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.

Break from the loop instead of returning the function.  This calls
player_stop_decoder(), which in turn emits the PLAYLIST event.  This
allows the playlist to re-start the player.