Did you ever accidently click "stop" while feeding a radio station?
This option sets the output device to "pause" to disable the "close"
method.  It falls back to "pause" then, which is specific to the
plugin.  Some plugins implement it by feeding silence.

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.

This command manually drains the hardware buffer.  This is useful when
the player thread want to make sure that everything has been played.

Always keep the audio_output object locked within the output thread,
unless a plugin method is called.  This fixes several race conditions.

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.

This allows more sophisticated audio format selection.

Explicitly make the output thread leave the ao_pause() loop.  This
patch is a workaround, and the "pause" flag is not managed in a
thread-safe way, but that's good enough for now.

This patch adds initial filter support for audio outputs.  Each audio
output gets a "filter" attribute, which is used by ao_play_chunk().

The PCM conversion is now performed by convert_filter_plugin.
audio_output.convert_state has been removed.

REOPEN is called when the input audio format changes.  The output
thread may be reconfigure the PCM converter.

The mixer core library is now responsible for creating and managing
the mixer object.  This removes duplicated code from the output
plugins.

There was a deadlock between the output thread and the player thread:
when the output thread failed (and closed itself) while the player
thread worked with the audio_output object, MPD could crash.

The config_audio_format used to contain the configured audio format,
which is copied to out_audio_format.  Let's convert the former to a
boolean, which indicates whether out_audio_format was already set.
This simplifies some code and saves a few bytes.

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.

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.

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.

The meaning of the chunk depends on the audio format; don't suggest a
specific format by declaring the pointer as "char*", pass "void*"
instead.

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

Now that the output_command enum isn't exposed to output plugins
anymore, we can hide its definition within output_internal.h.

Renamed audio_output struct members.

output_api.h is required for enum audio_output_command.

Removed yet another superfluous buffer layer: return the PCM buffer
from pcm_convert() instead of copying PCM data into the
caller-supplied buffer.

All what's left in pcm_utils.h is the pcm_range() utility function,
which is only used internally by pcm_volume and pcm_mix.

Use GLib locking (GMutex, GCond) instead of pthread because GLib is
more portable, e.g. on mingw32.

"LOG_H" is a macro which is also used by ffmpeg/log.h.  This is
ffmpeg's fault, because short macros should be reserved for
applications, but since it's always a good idea to choose prefixed
macro names, even for applications, we are going to do that in MPD.

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.

Don't return 0/-1 on success/error, but true/false.  Instead of int,
use bool for storing flags.

No CamelCase, and a struct instead of a typedef.

To check whether a device is really on or off, we should rather check
audio_output.open, instead of managing another variable.  Wrap
audio_output.open in the inline function audio_output_is_open() and
use it instead of DEVICE_ON and DEVICE_OFF.

Send an output buffer to all output plugins at the same time, instead
of waiting for each of them separately.  Make several functions
non-blocking, and introduce the new function audio_output_wait_all()
to synchronize with all audio output threads.

We have eliminated direct accesses to the audio_output struct from
the all output plugins.  Make it opaque for them, and move its real
declaration to output_internal.h, similar to decoder_internal.h.

Pass the opaque structure to plugin.init() only, which will return the
plugin's data pointer on success, and NULL on failure.  This data
pointer will be passed to all other methods instead of the
audio_output struct.

Get rid of CamelCase, and don't use a typedef, so we can
forward-declare it, and unclutter the include dependencies.

decode.c should be a lot smaller; start by moving all code which
handles cross-fading to crossfade.c.  Also includes camelCase
conversion.

Include only headers which are really required.  This speeds up
compilation and helps detect cross-layer accesses.

git-svn-id: https://svn.musicpd.org/mpd/trunk@7372 09075e82-0dd4-0310-85a5-a0d7c8717e4f

We had functions names varied between
outputBufferFoo, fooOutputBuffer, and output_buffer_foo

That was too confusing for my little brain to handle.
And the global variable was somehow named 'cb' instead of
the more obvious 'ob'...

git-svn-id: https://svn.musicpd.org/mpd/trunk@7355 09075e82-0dd4-0310-85a5-a0d7c8717e4f