When printing the error message, MPD dereferences the NULL pointer to
print an error message if no audio_output section is present.

In NDEBUG, clear_tail_chunk() does not use its "chunk" parameter.

The source output_all.c accesses music_chunk struct members, but did
not include chunk.h directly.

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.

When there are chunks which are not yet finished,
audio_output_all_check() returned the size of its music pipe minus
one.  I can't remember exactly why I subtracted 1 from the return
value, it must have had something to do with a former meaning of this
function.  Now it induces assertion failures.

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.

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.

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".

audio_output_all_update() returns true when there is at least open
output device which is open.

Do error handling with GError instead of aborting with g_error().

time() is not a monotonic timer, and MPD might get confused by clock
skews.  clock_gettime() provides a monotonic clock, but is not
portable to non-POSIX systems (i.e. Windows).  This patch uses GLib's
GTimer API, which aims to be portable.

When all outputs are disabled, MPD printed only a meaningless message
"problems opening audio device", although it didn't attempt to open a
device.

After initialization, audio_outputs is always non-NULL.  Don't check
that.

Don't include output_api.h in output_internal.h.  This change requires
adding missing includes in several sources.

When MPD explicitly starts playing, ignore the "REOPEN_AFTER" timeout.
This timeout was useful when MPD attempted to reopen a failed device
over and over, but it confuses users when they explicitly tell MPD to
start playing, while MPD insists to wait for the 10 seconds to pass.

audio_output_all_finished() returns bool, not int.

Renamed functions and variables.

Moved code which deals with all audio outputs at once into a separate
library.

This function isn't used anymore.

Added audio_output_get(), audio_output_find().

audio_output_config_count() returns the number of audio outputs in the
configuration file.  It is only used by initAudioDriver().  The public
function audio_output_count() now returns audioOutputArraySize.

On some platforms, g_free() must be used for memory allocated by
GLib.  This patch intends to correct a lot of occurrences, but is
probably not complete.

Those have been superseded by the new legacy configuration code.

All config_get_block_*() functions should accept constant config_param
pointers.

Renamed functions, types, variables.

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

Replaced myFgets() with fgets() + g_strchomp().

Don't use NOTIFY_INITIALIZER to initialize audio_output_client_notify.

Nobody should call playAudio() with an empty chunk.  Add some
assertions on that.

Since open() and play() close the device on error, we can simply check
audio_output.open instead of audio_output.result after a call.

When one of several output devices failed, MPD tried to reopen it
quite often, wasting a lot of resources.  This patch adds a delay:
wait 10 seconds before retrying.  This might be changed to exponential
delays later, but for now, it makes the problem go away.