Some decoder commands are implemented in the decoder plugins, thus
they need to have an API call to signal that their current command has
been finished.  Let them use the new decoder_command_finished()
instead of the internal dc_command_finished().

Another big patch which hides internal mpd APIs from decoder plugins:
decoder plugins regularly poll dc->command; expose it with a
decoder_api.h function.

Since we moved all PCM conversions to decoder_data(), the attribute
convState isn't being used anymore by the OutputBuffer code.  Move it
to struct decoder.

We want to expose the AudioFormat structure to plugins; remove some
clutter by moving its declaration to a separate header file.

InputPlugin is the API which is implemented by a decoder plugin.  This
belongs to the public API/ABI, so move it to decoder_api.h.  It will
later be renamed to something like "decoder_plugin".

Anonymous code blocks just to declare variables look ugly.  Move the
variable declarations up and disband the code block.

Similar to previous patch: eliminate one variable by using "break".
This also simplifies the code since we can remove one level of indent.

"break" is so much easier than "eof=1; continue;", when "!eof" is the
loop condition.

Since we have merged dc->stop, dc->seek into one variable, we don't
have to check both conditions at a time; we can replace "!stop &&
!seek" with "none".

Similar to the previous patch: pass total_time instead of manipulating
dc->totalTime directly.

dc->audioFormat is set once by the decoder plugins before invoking
decoder_initialized(); hide dc->audioFormat and let the decoder pass
an AudioFormat pointer to decoder_initialized().

We are now beginning to remove direct structure accesses from the
decoder plugins.  decoder_clear() and decoder_flush() mask two very
common buffer functions.

Code simplification: since we are not using in-band signalling with
the chunk index anymore, we can just return a pointer to the tail
chunk instead of the index.

OutputBuffer should be a more generic low-level library, without
dependencies to the other headers.  This patch adds the field
"notify", which is used to signal the player thread.  It is passed in
the constructor, and removes the need to compile with the decode.h
header.

Moved all of the player-waiting code to decoder_data(), to make
OutputBuffer more generic.

Avoid some duplicated code in main_notify.c.

After the decoder has been initialized and the audio device has been
opened, don't sleep.  The decoder plugin won't do anything special nor
will it care to wake us up for some reason.

decoder_initialized() sets the state to DECODE_STATE_DECODE and wakes
up the player thread.  It is called by the decoder plugin after its
internal initialization is finished.  More arguments will be added
later to prevent direct accesses to the DecoderControl struct.

The decoder struct should later be made opaque to the decoder plugin,
because maintaining a stable struct ABI is quite difficult.  The ABI
should only consist of a small number of stable functions.

Don't use wrappers like player_wakeup_decoder_nb().  These have been
wrappers calling notify.c functions, for compatibility with the
existing code when we migrated to notify.c.

The "if" block breaked out of the loop.  That means we can move the
code out of the "else" block.

dc_command_finished() is invoked by the decoder thread when it has
finished a command (sent by the player thread).  It resets dc.command
and wakes up the player thread.  This combination was used at a lot of
places, and by introducing this function, the code will be more
readable.

Busy wait loops are a bad thing, especially when the response time can
be very long - busy waits eat a lot of CPU, and thus slow down the
other thread.  Since the other thread will notify us when it's ready,
we can use notify_wait() instead.

Much of the existing code queries all three variables sequentially.
Since only one of them can be set at a time, this can be optimized and
unified by merging all of them into one enum variable.  Later, the
"command" checks can be expressed in a "switch" statement.

pc->errored_song is already set by decodeParent() in the player thread
when we set dc->error; no need to set it in the decoder thread.

Since pc->current_song denotes the song which the decoder should use
next, we should move it to DecoderControl.  This removes one internal
PlayerControl struct access from the decoder code.

Also add pc.next_song, which is manipulated by the playlist code, and
gets copied to dc.next_song as soon as the decoder is started.

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

Also enable -Wunused-parameter - this forces us to add the gcc
"unused" attribute to a lot of parameters (mostly library callback
functions), but it's worth it during code refactorizations.

Previously, it was not possible to check for e.g. "-std=c99".

Fix a "unused argument" warning, and several warnings regarding void
pointer calculation.

Fix a "signed/unsigned comparison warning", and several void pointer
math warnings.

* Correctly define the following CPP directives:
  HAVE_FAAD_BUFLEN_FUNCS
  HAVE_MP4AUDIOSPECIFICCONFIG

* link against libwavpack correctly in bs

* fix include path for the mpd config.h for mp4ff

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

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

If nothing has been read from the input stream, we don't have to
rewind it.

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

The variable "to_read" is never modified except in the last iteration
of the while loop.  This means the while condition will never become
false, as the body will break before that may be checked.

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

Start using it in the HTTP code

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

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

This institutes the usage of a separate thread to buffer HTTP
input.  It is basically practice code for using the ringbuffer
code which I plan on reusing for the OutputBuffer as well as
further input buffering for disk (networked filesystems over
WAN, laptops on battery, etc).

Each readFromInputStream() call on an HTTP stream can take
several seconds to complete, short reads are avoided.

A single-threaded solution for systems supporting large enough
SO_RCVBUF values should also be possible and will likely be done
in the future; but this lock-free(except when full/empty)
ringbuffer is cool :)

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

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

We'll be using pipes when waiting for I/O, and condition
variables at other times.

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