This function was part of a workaround which we don't need anymore.

After adding the container_scan() method the update_regular_file() method was quite hard to read.
Now there's update_container_file() which deals with container files.
That way normal container files (i.e. without embedded tracks) are handled by the old code like a regular file.
This will fix some of the odd behaviour observed.

snd_pcm_writei() returns the type snd_pcm_sframes_t, not int.  Use the
correct variable type.

If the PCM handle gets disconnected, don't close and clear it in
alsa_recover().  The MPD core will call alsa_close() anyway.  This
way, we can always assume that alsa_data.pcm is always valid.

After a seek, wait until enough new chunks are decoded before starting
playback.  If this takes too long, send silence chunks to the audio
outputs meanwhile.

When the audio outputs are closed, also clear the audio format.  If we
don't do this, every call to audio_output_all_update() will open the
device, even if it's meant to be paused.

Don't allow reopening an audio device after pause with
audio_format==NULL, force the caller to provide the audio_format each
time.

When playback is unpaused, pass the audio_format to
audio_output_all_open().  Don't assume that output_all.c remembers the
previous audio format.  Also check if there has been an audio format
yet.

Check audio_output.command after each sub-chunk has been played.  It
discards the rest of the chunk, but since all commands make the device
stop anyway, this is not a problem, but part of the improvement.  This
improves the latency of audio output commands.

When seeking into a new song, and the decoder for the new song fails
to start up, MPD forgot to send the "command_finished" signal to the
main thread.

When pc.next_song is reset due to a decoder failure, also reset the
player.queued flag.  player.queued must not be true when there is no
pc.next_song.

Reset player.xfade and player.buffering from within
player_seek_decoder(), not in the player_process_command() switch
statement.

A larger chunk size means less overhead for managing them.  4 kB seems
to be a reasonable choice: it contains 23 ms of 44.1 kHz 16 bit stereo
data, or 3 ms of 192 kHz 24 bit stereo data.  The original value of
1020 seemed to be too small, there were quite a lot of system calls
and context switches.

The "run_output" program can be used to test an audio output plugin in
an isolated environment.

The music_buffer is a global variable, and must not be freed until the
player thread exits.

Instead of passing individual buffers to audio_output_all_play(), pass
music_chunk objects.  Append all those chunks asynchronously to a
music_pipe instance.  All output threads may then read chunks from
this pipe.  This reduces MPD's internal latency by an order of
magnitude.

When a PAUSE command is received while the decoder starts, don't open
the audio device when the decoder becomes ready.  It's pointless,
because MPD will close if after that.

Moved some more cruft out of do_play().

Moved some cruft out of do_play().

Preparation for the next patch: since the output devices stay open
even when the player thread stops playing, we will need a persistent
music buffer.

audio_output_open() is only called by audio_output_update().  Don't
export it.

When a music chunk is freed (returned to the buffer), poison its
memory.

If the header valgrind/memcheck.h is available, add
VALGRIND_MAKE_MEM_NOACCESS() and VALGRIND_MAKE_MEM_UNDEFINED()
support, which enables nice warnings in the valgrind memory checker.

Memory poisoning is useful for marking memory regions as "undefined".
This poisoning only enabled in the debug build (!NDEBUG).

This is similar to the MPD 0.14 patch "wait 10 seconds before
reopening a failed device", which only covered open() failures.  This
patch adds the same feature for play().

Until now every flac file got removed unconditionally (and then re-added)
whenever the update command was issued. Now there is a check if we need
to that, so the file will only be removed if there is a embedded cuesheet
in that file

So far only seekpoints are supported, so no proper tagging yet
except for track number and track length.
Tagging should be done by parsing the cue sheet which
is often embedded as vorbis comment in flac files.
Furthermore the pathname should be configurable like "%A - %t - %T",
where %A means Artist, %t track number and %T Title or so.

[mk: fixed whitespace errors; use delete_song() instead of
songvec_delete()]

In !NDEBUG, remember which audio_format is stored in every chunk and
every pipe.  Check the audio_format of every new data block appended
to the music_chunk, and the format of every new chunk appended to the
music_pipe.

This patch fixes a theoretical (but practically impossible) flaw: the
variable "buffer_time" may be uninitialized when it is used.
Initialize the variable with snd_pcm_hw_params_get_buffer_time().

The default values for buffer_time and period_time were both capped by
the hardware limits on practically all chips.  The result was a
period_time which was half as big as the buffer_time.  On some chips,
this led to lots of underruns when using a high sample rate (192 kHz),
because MPD had very little time to send new samples to ALSA.

A period time which is one fourth of the buffer time turned out to be
much better.  If no period_time is configured, see how much
buffer_time the hardware accepts, and try to configure one fourth of
it as period_time, instead of hard-coding the default period_time
value.

This is yet another attempt to provide a solution which is valid for
all sound chips.  Using the SND_PCM_NONBLOCK flag also seemed to solve
the underruns, but put a lot more CPU load to MPD.

Sometimes, audio_output_update() isn't called for the second device
when the first one has succeeded.  The patch
"audio_output_all_update() returns bool" broke it, because the boolean
evaluation ended after the first "true".

Another "remove redundant explicit $enableval assignments" breakage.

Added two assertions.

When the decoder chunk is empty in decoder_flush_chunk(), don't push
it into the music pipe - return it to the music buffer instead.  An
empty chunk in the pipe wastes resources for no advantage.