Rename it to audio_format_equals() and return "true" if they are
equal.

The "!src" check in copyAudioFormat() used to hide bugs - one should
never pass NULL to it.  There is one caller which might pass NULL, add
a check in this caller.

Instead of doing mempcy(), we can simply assign the structures, which
looks more natural.

Getting rid of CamcelCase, again.

Similar to decoder_control.c, output_control.c will provide functions
for controlling the output thread (which will be implemented later).

No CamelCase.  Also don't declare typedefs for the methods.

This function is declared, but is neither used nor implemented.

The audio_format argument to timer_new() should be constant, because
it is not modified.  The same is true for ShoutData.audioFormat.

Otherwise we'd be writing to whatever directory that mpd is
running in.

The way we used non-blocking mode was HORRIBLE.

It was non-blocking to ALSA, but we end up blocking in a busy
loop that does absolutely NOTHING but retry.  We don't check
for playback cancellation (like we do in decoders) or anything.

This is seriously broken and I can imagine it affects people on
fast CPUs more because we do asynchronous output buffering and
our ALSA device will always have data ready.

Lets not use deprecated functions. It's apparently
possible to not care about the sw_params stuff at all!

This is safer than the patch in
  http://www.musicpd.org/mantis/view.php?id=1542
with multiple audio outputs enabled.

Sadly, I only noticed that patch/problem when I googled for
"snd_config_update_free_global"

We never use it for anything anyways as we release the device
entirely on pause.

That's the name of this project.

Apparently snd_pcm_hw_params_can_resume() can return false even
though my hardware does in fact support resuming.  So stop
carrying that value in the canResume flag and just try to resume
when we're in the suspended state; falling back to
snd_pcm_prepare only if resuming fails.  libao does something
similar on resume, too.

While we're at it, use the E() macro which will enable us to
have better error reporting.

[mk: remove the E() macro stuff]

Due to a minor typo, the string set had duplicate values, because
strset_add() didn't check the base slot properly.

With a large music database, the linear string collection in
tagTracker.c becomes very slow.  We implemented that in a
quick'n'dirty fashion when we removed tree.c, and now we rewrite it
using the fast hashed string set.

"struct strset" is a hashed string set: you can add strings to this
library, and it stores them as a set of unique strings.  You can get
the size of the set, and you can enumerate through all values.

This will be used to replace the linear tagTracker library.

Since the plugin struct is never modified, we should store it in
constant locations.

Instead of having to register each output plugin, store them
statically in an array.  This eliminates the need for the List library
here, and saves some small allocations during startup.

Instead of copying all that stuff from the audio output plugin to the
audio output structure, store a pointer to the plugin.

Also rename AudioOutputPlugin to struct audio_output_plugin, and use
forward declarations to reduce include dependencies.

Just like decoder_api.h, output_api.h provides the audio output API
which is used by the plugins.

Due to clumsy layout, the audio_format struct took 12 bytes.  Move the
"channels" to the end, so it can be merged into the same 32 bit slot
as "bits", which reduces the struct size to 8 bytes.

Get rid of CamelCase, and don't use a typedef, so we can
forward-declare it, and unclutter the include dependencies.

print_playlist_result() had an assert(0) at the end, in case there was
an invalid result value.  With NDEBUG, this resulted in a function not
returning a value - add a dummy "return -1" at the end to keep gcc
quiet.

Since all callers of song_id_exists() will map it to a song position
after the check, introduce a new function called song_id_to_position()
which performs both the check and the map lookup, including nice
assertions.

Don't pass a pointer to client->permission to processCommand(), better
let the code in command.c use the new permission getter/setter
functions.

The code in command.c shouldn't mess with a pointer to
client->permission.  Provide an API for accessing this value.

Some functions don't want to modify a client's permission set.  Pass
the permissions to them by value, not by reference.

volatile provides absolutely no guarantee thread-safety in SMP
environments.  volatile was designed to access memory locations
in peripheral hardware directly; not for SMP.  If volatile is
needed to work properly on SMP, then it is only hiding subtle
bugs.

volatile only prevents the /compiler/ from making optimizations
when accessing variables.  CPUs do their own optimizations at
runtime so it cannot guarantee registers of CPUs are flushed
to memory cache-coherent access on different CPUs.

Furthermore, the thread-communication via condition variables
between threads sharing audio formats already results in memory
barriers.

Gah, it seems like doing sizeof here either way is error
prone.  Too easy to leave out a '*' character we can
forget.

The tag pool is a shared global resource that is infrequently
modified.  However, it can occasionally be modified by several
threads, especially by the metadata_pipe for streaming metadata
(both reading/writing).

The bulk tag_item pool is NOT locked as currently only the
update thread uses it.

Trying to read or remember
  "tag->numOfItems * sizeof(*tag->items)"
requires too much thinking and mental effort on my part.

Also, favor "sizeof(struct mpd_tag)" over "sizeof(*tag->items)"
because the former is easier to read and follow, even though
the latter is easier to modify if the items member changes
to a different type.

The previous patch enabled these warnings.  In Eric's branch, they
were worked around with a generic deconst_ptr() function.  There are
several places where we can add "const" to pointers, and in others,
libraries want non-const strings.  In the latter, convert string
literals to "static char[]" variables - this takes the same space, and
seems safer than deconsting a string literal.

We're pretty careful about using const these days, so
enable these warnings to keep us that way.

All callers of fdprintf() have been converted to client_printf() or
fprintf(); it is time to remove this clumsy hack now.  We can also
remove client_print() which took a file descriptor as parameter.

Now that we have removed all invocations of client_get_fd(), we can
safely remove this transitional function.  All access to the file
descriptor is now hidden behind the interface declared in client.h.

Pass the client struct instead.