Renamed playerSeek() to pc_seek() to get rid of CamelCase.  Convert
the return value to bool.

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.

Turn the music_pipe into a simple music_chunk queue.  The music_chunk
allocation code is moved to music_buffer, and is now managed with a
linked list instead of a ring buffer.  Two separate music_pipe objects
are used by the decoder for the "current" and the "next" song, which
greatly simplifies the cross-fading code.

player_control.thread contains the handle of the player thread, or
NULL if the player thread isn't running.

Older gcc versions complained about shadowed parameters in prototypes.

When a (remote) song is deleted from the playlist, there may still be
a reference to it in pc.errored_song.  Clear this reference.

Removed the "volatile" attributes from several variables which are not
important for synchronization.

Renamed variables and internal functions.  Most of the
player_control.h API remains in CamelCase for now.

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

QUEUE adds a new song to the player's queue.  CANCEL clears the queue.
These two commands replace the old and complex queueState and
queueLockState code.

This variable is superfluous, it is only used to copy its value to
player_control.totalTime.  Since the original source of this value
(song->tag->time) will still be available at this point, we can safely
remove fileTime.

player_get_audio_format() replaces getPlayerSampleRate(),
getPlayerBits(), getPlayerChannels().

This replaces the attributes bits, channels, sampleRate.

When there are standardized headers, use these instead of the bloated
os_compat.h.

Typedefs shouldn't be used, use the bare struct names instead.

Again, a data type which can be forward-declared.

Since we use a C99 compiler now, we can assert that the C99 standard
headers are available, no need for complicated compile time checks.
Kill mpd_types.h.

Do full C99 integer type conversion in all modules which were not
touched by Eric's merged patch.

Destroy the mutex when it is not used anymore.

Give player.c a better name, meaning that the code is used to control
the player thread.

We should avoid having protocol specific code in player.c.  Just
return success or failure, and let the caller send the error code to
the MPD client.

This is the last of the three variables.  Now we don't need
playerData.h anymore in most sources.

Since playerPlay() already calls playerStop(), we can remove its
invocation of playerStop() from playPlaylistOrderNumber().

We can also make playerStop a static function.

All (indirect) callers of queueSong() ensure that the queue state is
BLANK, so there is no need to check it in queueSong() again.  As a
side effect, queueSong() cannot fail anymore, and can return void.
Also, playlist_queueError and all its error handling can go away.

playerKill() was marked as deprecated, but it seems like a good idea
to do proper cleanup in all threads (e.g. for usable valgrind
results).  Introduce the command "EXIT" which makes the player thread
exit cleanly.

Most player*() functions do not actually use the file descriptor, and
always return 0 (success).  Eliminate them to get a leaner interface.

Don't write CPP when you can express the same in C...  macros vs enum
is a good example for that.

PlayerControl.command replaces the old attributes play, stop, pause,
closeAudio, lockQueue, unlockQueue, seek.  The main thread waits for
each command synchronously, so there can only be one command enabled
at a time anyway.

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.

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.

It actually increases our image size a small bit and may even
hurt performance a very small bit, but makes the code less
verbose and easier to manage.

I don't see a reason for mpd to ever support playing multiple
files at the same time (users can run multiple instances of mpd
if they really want to play Zaireeka, but that's such an edge
case it's not worth ever supporting in our code).

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

The select() in the main event loop blocks now (saving us many
unnecessary wakeups).  This interacted badly with the threads
that were trying to wakeup the main task via
pthread_cond_signal() since the main task was not blocked
on a condition variable, but on select().

So now if we detect a need to wakeup the player, we write
to a pipe which select() is watching instead of blindly
calling pthread_cond_signal().

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

Another global variable cleanup patch.

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