The date parameter is always zero, remove it.

This occurs when the output is really late (typically as a side effect
of glitches in pause/resume). Both FIFOs  are now both protected with
the same lock, so there is no room for race conditon between the two
identical checks anymore. So we can handle both checks in one go.

This prepares for a possible cleanup of the audio output object,
especially hiding more stuff into the core.

With only one input per output, the lock is only useful:
 - to restart the audio instance (needed 3 out of 4 locks anyway),
 - to propagate volume change to the mixer or output plugin,
 - to access the FIFO from the output plugin thread (if applicable).

So 4 fine-grained was over-engineering. Most importantly, the locking
scheme was overly complicated and generally misunderstood/misused. Also
to avoid lock inversion, some unlocking/relocking sequences were
introduced; they broke atomicity.

We could certainly reduce the scope of the remaining lock. Since we
have one only input per output, most of the code is only ever run from
the decoder thread. Thus reentrancy is not anymore needed in some
places. But first aout_Restart() needs to be fixed and simplified.

The audio input drops expired packets before they hit the mixer. Since
we only support a single input per mixer, the mixer check is mostly
redumdant.

Now the mixer can focus on applying to volume. Dummy mixers for
S/PDIF and linear are now merged.

Only software amplification is left

(Yeah, some automatic variables were renamed too)

aout_buffer_t now looks very much like a subset of block_t at the
source code level. By the way, we might want to revisit the return value
of date_Increment()...

This will be needed to replace aout_buffer_t with block_t.
We also need to replace end_date with i_length, which is a bit more
involved.

alloca() was not used anyway on OSX and BSD, due to smaller stack sizes,
and we can't assume a default stack size anyway

I expect the performance loss to be minimal, but worth the code
simplification anyway (i didn't benchmark)

aout_BufferAlloc() is moved into its own function in a .c file instead
of being a macro

Since there is now 2 types of allocations (HEAP and NONE), make
i_alloc_type a boolean (true = HEAP alloc, false = NO alloc)

make aout_BufferFree() a static inline function in the same process.
Prototype doesn't change since the provided buffer doesn't need to be
set to NULL (I checked all the callers)

It will allow to sanetize aout_instance_t.

This does not work well. It seems that a high level of audio is buffered
inside aout after the input fifo (mixer or output one).