Now that the player thread can handle SEEK commands while not (yet)
playing, we can remove the "pc.state" check from pc_seek().

These fixes were mostly generated with `codespell' [0] and manually
reviewed.

[0] http://git.profusion.mobi/cgit.cgi/lucas/codespell/

Remove the decoder dependency on player_control.  All player_control
was needed for is to signal the player thread, and we can do that with
a simple GCond as well.

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.

Race condition fix.

Adds mixrampdb and mixrampdelay commands.  Reads MIXRAP_START and
MIXRAMP_END tags from FLAC files and overlaps instead of crossfading.

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.

The assertion shouldn't access player_control.next_song without
locking it.

Don't wake up the target thread in every iteration of the wait() loop.
Waking it up once, right after the command has been set, must be
enough.

These parameters must be protected with a mutex, too.  Wrap everything
inside player_lock()/player_unlock(), and use player_command_locked()
instead of player_command().

Allocate a decoder_control object where needed, and pass it around.
This will allow more than one decoder thread one day.

Use GMutex/GCond instead of the notify library.  Manually lock the
player_control object before accessing the protected attributes.  Use
the GCond object to notify the player thread and the main thread.

With these methods, an output plugin can allocate some global
resources only if it is actually enabled.  The method enable() is
called after daemonization, which allows for more sophisticated
resource allocation during that method.

Tracking the "elapsed" time from the chunks which we have sent to the
output pipe is very imprecise: since we have implemented the music
pipe, we're sending large number of chunks at once, giving the
"elapsed" time stamp a resolution of usually more than a second.

This patch changes the source of this information to the outputs.  If
a chunk has been played by all outputs, the "elapsed" time stamp is
updated.

The new command PLAYER_COMMAND_REFRESH makes the player thread update
its status information: it tells the outputs to update the chunk time
stamp.  After that, player_control.elapsed_time is current.

Sending PLAYER_COMMAND_STOP followed by PLAYER_COMMAND_QUEUE does the
same.  PLAYER_COMMAND_PLAY is redundant.

After some of the commands, the player thread must have reset the
pc.next_song attribute.

Without the player error code, it errored_song variable is not used,
and should be cleared, to avoid invalid access in pc_song_deleted().

The new player_status struct replaces a bunch of playerGetX()
functions.  When we add proper locking to the player_control struct,
we will only need to lock once for the "status" command.

This lets us eliminate the static fixed-size buffer.

Do all the software volume stuff inside each output thread, not in the
player thread.  This allows one software mixer per output device, and
also allows the user to configure the mixer type (hardware or
software) for each audio output.

This moves the global "mixer_type" setting into the "audio_output"
section, deprecating the "mixer_enabled" flag.

The player thread must reset pc.next_song after seeking, even if that
operation has failed.  This patch adds an assertion.

The only pc_seek() caller clears the error, rendering the check
useless.  Even if the previous PLAY command resulted in a player
error, this check is not very useful.

Renamed playerSeek() to pc_seek() to get rid of CamelCase.  Convert
the return value to bool.

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.

Turn the music_pipe into a simple music_chunk queue.  The music_chunk
allocation code is moved to music_buffer, and is now managed with a
linked list instead of a ring buffer.  Two separate music_pipe objects
are used by the decoder for the "current" and the "next" song, which
greatly simplifies the cross-fading code.

Assertions on pc.command and pc.next_song.

When the playlist is cleared, pc.errored_song is also cleared.  This
causes pc_errored_song_uri() to crash, because it assumes that
pc.errored_song is set.  Reset pc.error to fix that assumption.

player_control.thread contains the handle of the player thread, or
NULL if the player thread isn't running.

Moved the software volume code to a separate library.

There is only one location using PIPE_EVENT_SIGNAL: to synchronize
player_command() with player_command_finished().  Use the "notify"
library instead of the event_pipe here.

Continuing the previous patch.

We are going to migrate away from the concept of notifying the main
thread.  There should be events sent to it instead.  This patch starts
a series to implement that.

Only include headers which are really needed.  os_compat.h aimed to
make MPD easily portable, but was never actually made portable.

getPlayerErrorStr() assumes that pc.errored_song is set when an error
occured.  Since the song may have been deleted meanwhile, add a NULL
check.