replay_gain_get_real_mode() accesses dangerous globals.  Let's just
use the global variable replay_gain_mode, and assume "AUTO" means
"TRACK".  At this point, this is the best we can do, because neither
the decoder nor the player should know about the current replay gain
mode.  This is applied as a filter in the output thread.

Let the function decoder_replay_gain() update
decoder_control::replay_gain_db instead of letting each decoder plugin
take care for that.

Eliminate support for reverse endian samples from the MPD core.  This
moves a lot of complexity to the plugins that really need it (only
ALSA and CDIO currently).

This fixes seeking in the vorbis decoder during MPD startup.

Fixes assertion failure.

This checks both conditions: pending and running.  Fixes yet another
assertion failure!

.. and add a few code comments.

Don't read song.start_ms and song.end_ms, let the player thread manage
this logic instead.

Fixes one more assertion failure.

Fixes possible assertion failure.

When playing a CUE track, the player thread waited for the decoder to
become ready, and then sent a SEEK command to the beginning of the CUE
track.  If that is near the start of the song file, and the track is
short enough, the decoder could have finished decoding already at that
point, and seeking fails.

This commit makes this initial seek more robust: instead of letting
the player thread deal with the difficult timings, let the decoder API
emulate a SEEK command, and return it to the decoder plugin, as soon
as the plugin finishes its initialization.

Add GMutex, GCond attributes which will be used by callers to
conditionally wait on the stream.

Remove the (now-useless) plugin method buffer(), wait on GCond
instead.  Lock the input_stream before each method call.  Do the same
with the playlist plugins.

This was useless, because input_stream_read() blocks until data is
available.  Calling it in a loop doesn't make sense.

This is not necessary since all relevant input plugins have been moved
to the I/O thread, and there is no remaining useful buffer()
implementation.  This also fixes a busy loop when playing radio.

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.

Pay attention to the ReplayGain mode "auto" and the
replay_gain_missing_preamp parameter inside of decoder_replay_gain().

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

When decoder->timestamp is calculated, the PCM data is already
converted to out_audio_format; using in_audio_format may cause funny
speedups/slowdowns.

Apply the replay gain in the output thread.  This means a new setting
will be active instantly, without going through the whole music pipe.
And we might have different replay gain settings for each audio output
device.

Use input_stream.uri.

The replay_gain_state struct holds the precalculated scale factor,
which is removed from struct replay_gain_info.

This function replaces the replay_gain_info parameter for
decoder_data().  This allows the decoder to announce replay gain
changes, instead of having to pass the same object over and over.

Seek the decoder to the start of the range before beginning with
playback.  Stop the decoder when the end of the range has been
reached.  Add the start position to the seek position.  Expose the
duration of the range, not the full song file.

Remove the data_time parameter from decoder_data().  This patch
eliminates the timestamp counting in most decoder plugins, because the
MPD core will do it automatically by default.

Don't clear the music pipe when seeking has failed - check the
"seeking" flag instead of "command==SEEK".  Clear the "seeking" flag
in decoder_seek_error().

Use the plugin instead of the glue code in normalize.c.  This is used
wrapped inside a "autoconv" filter, to enable normalization for all
input file formats.