The wavpack library seems to use the .wvc stream even if the OPEN_WVC
flag is not set.  In this case, pass NULL to be sure libwavpack won't
use it.

Removed all allocation functions, xwrite(), xread(), ARRAY_SIZE().
Those have been superseded by GLib.

Use GLib's G_GNUC_UNUSED instead of gcc.h's mpd_unused.

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

SEEK_SET is defined by unistd.h.  Explicitly include it.

Refuse to play audio formats which are not supported by MPD.

Somehow we lost 600e1322 after renaming some variables in ed6f6046.

Define the special value "-1" as "unknown size".  Previously, there
was no indicator for streams with unknown size, which might confuse
some decoders.

The wavpack open function gives us an option called OPEN_STREAMING. This
provides more robust and error tolerant playback, but it automatically
disables seeking. (More exactly the wavpack lib will not return the
length information.) So, if the stream is already not seekable we can
use this option safely.

Wavpack plugin doesn't stop decoding if a block couldn't be fully
decoded, rather it tries to go on.

The stream_decode() and file_decode() methods returned a boolean,
indicating whether they were able to decode the song.  This is
redundant, since we already know that: if decoder_initialized() has
been called (and dc.state==DECODE), the plugin succeeded.  Change both
methods to return void.

Having an array instead of individual variables allows the use of the
replay_gain_mode enum as an array index.

The function simplifies wavpack_replaygain(), because it already
contains the float parser, and it works with a fixed buffer instead of
doing expensive heap allocations.

This allows us to remove the "static char[]" hack.

Renamed functions and variables.

Wavpack's try_decode() implementation does nothing useful, it only
duplicates code already in stream_decode() / file_decode(), and slows
down MPD.

This patch makes 24-bit samples available for mpd. I tested with the
WavPack Test Suite found on wavpack.com:

 http://www.rarewares.org/wavpack/test_suite.zip

Every test file worked fine.

At this moment the wavpack lib doesn't use the return value of the
push_back function, which has an equivalent meaning of the return
value of ungetc().  This is a lucky situation, because so far it
simply returned with 1 as a hard coded value.  From now on the
function will return EOF on error.  (This function makes exactly one
byte pushable back.)

A new function has been added to do a cast and a little check in the
wavpack-mpd input stream wrapper.

I think this makes the code more easily modifiable and prevents some
annoying mistakes.

There are some functions in the wavpack-mpd input streams wrapper
which had too commonly used names (especially can_seek). I prefixed
these with "wavpack_input_".

Not every function header has its return type in a distinct line. This
patch corrects that.  This way there is more space for the arguments.

Using wvc streams the seekableness depends on the seekability of the
wvc stream as well.

The input stream opened for wvc is not closed in an if branch.  A
close call has been added.

Somehow seeking is disabled on all kinds of wavpack playbacks now in
the git version.  This patch corrects that.

libwavpack expects the read_bytes() stream method to fill the whole
buffer, and fails badly when we return a partial read (i.e. not enough
data available yet).  This caused wavpack streams to break.
Re-implement the buffer filling loop.

The input_stream object is opened and closed by the caller.

Instead of checking the stream_types bit set, we can simply check
whether the methods stream_decode() and file_decode() are implemented.

The number of tag types is known at compile time.  Use the GLib macro
G_N_ELEMENTS instead of having a NULL element at the end.

Don't store tag type values in a plain integer, use the proper enum.

Replace deprecated code with GLib.

Instead of manually waiting for the input stream to become ready (to
catch server errors), just read the first byte.  Since the
wavpack_input has the capability to push back one byte, we can simply
re-feed it.  Advantage is: decoder_read() handles everything for us,
i.e. waiting for the stream, polling for decoder commands and error
handling.

Use boolean true/false instead of 1/0.

Renamed functions and variables.