Add get_volume() and set_volume() methods to CoreAudio.

These methods will be added to the AudioOutput subclasses eventually
so GUI-based players can adjust system volume.
Add preliminary low-level PulseAudio support.

That is, instead of forking a pacmd instance and piping PCM data,
it'll have an audiotools.output.PulseAudio object instead.
Implementing it this way is less of a hack and enables easier
volume control.
Improve PulseAudio's connection callback sequence.

This essentially turns its asynchronous connection sequence
into a synchronous one since I don't want the __init__ method
to return until after a server connection is fully established.
Convert PulseAudio output to threaded operation.

Using its threaded API should allow it to function like CoreAudio
in that I can push data onto a thread-save FIFO with .play()
while the threaded callbacks deliver it to the PulseAudio daemon.
Convert PulseAudio output to libpulse-based implementation.

setup.py will probe for libpulse using pkg-config
to ensure it builds correctly and will omit PulseAudio support
if it does not.

The implementation is a fairly close match to PulseAudio's
"simple" streams, but with support for pausing/unpausing
and volume query/control.
Replace .player.AUDIO_OUTPUT with .available_outputs()

This should make it easier to swap in new types in the future
such as network-based sinks which may randomly come and go.
Update ExecProgressQueue to use select instead of polling.

That is, finished subprocesses are collected instantly
rather than waiting for the next quarter second poll.

Adding primitives from Python's multiprocessing module
should also cut down on potential bugs.  But although it seems
like swapping ExecProgressQueue for multiprocessing.Pool would be
a natural fit, Pool doesn't give enough feedback about when jobs
start or finish to manage the progress bars and it doesn't seem to
handle shared memory objects very well.
Convert .player.Player objects to use multiprocessing module.

This seems simpler and less error-prone than performing
forking, object passing and shared memory management personally.
Simplify AudioOutput object interface.

Since getting/setting volume often requires a connection,
setting up a default connection at a sensible output format
helps ensure volume adjustment works as expected even if audio isn't playing.
Add volume adjusting widget to trackplay's GUI.

This widget can be extended later to allow switching audio output.

The downside is that volume adjustment during playback is sluggish
since the player's command queue is lower priority than outputting audio
and both are processed in the same thread in the player subprocess.
Still pondering the best way to handle this.
Output can be changed interactively from trackplay/cdplay.

This will be more useful for network-based output sinks,
once I get around to supporting them.
Fix volume control to work more smoothly.

This involves updating the IPC protocol to make sending return values optional.
Therefore, the parent process can "fire and forget" volume changes
and the child process makes the adjustment whenever it gets a chance.
Add preliminary ALSA output support.
Fix ALSA output to work with 24bps streams.

Seems its 24-bit integer option isn't well supported
so it's better to switch to floats in that case.
Add volume control to ALSA output.
More fixes to PulseAudio output.

Clean out some very old output modules that were never in use.
Add volume control to OSS output.

Adjust output objects to refrain from opening output stream
until the output format is set or the volume is read/updated.
Merge branch 'master' of net:audiotools
Minor fixes, mostly to pass the unit tests.