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

Pass the client struct instead of the raw file descriptor.

Pass the client struct instead of the raw file descriptor.

The shared code in showPlaylist() isn't worth it, because we aim to
remove fdprintf().  Duplicate this small function, and enable stdio
buffering for saved playlists.

Pass the client struct instead of the raw file descriptor.

Pass the client struct instead of the raw file descriptor.

String literals (including those defined in CPP macros) can be
concatenated at compile time.  This saves some CPU cycles in
vsnprintf() at run time.

commandError() has been superseded by command_error(), and is not
being used anymore.  Remove it.

The function loadPlaylist() wants to report incremental errors to the
client, for this reason we cannot remove its protocol dependency right
now.  Instead, make it use the client struct instead of the raw file
descriptor.

Don't pass the raw file descriptor around.  This migration patch is
rather large, because all of the sources have inter dependencies - we
have to change all of them at the same time.

Pass the client struct to CommandHandlerFunction and
CommandListHandlerFunction.  Most commands cannot take real advantage
of that yet, since most of them still work with the raw file
descriptor.

Instead of passing the file descriptor, pass the client struct to
getCommandEntryAndCheckArgcAndPermission().

These two functions take a client struct instead of the file
descriptor.  We will now begin passing the client struct around
instead of a raw file descriptor (which needed a linear lookup in the
client list to be useful).

No protocol code in the audio output library.

The "volume" library shouldn't talk to the client.  Move error
handling to command.c.

Again, move error handling to command.c.

Move another ocurrence of error handling over to command.c.

This patch continues the work of the previous patch: don't pass a file
descriptor at all to traverseAllIn().  Since this fd was only used to
report "directory not found" errors, we can easily move that check to
the caller.  This is a great relief, since it removes the dependency
on a client connection from a lot of enumeration functions.

Database traversal should be generic, and not bound to a client
connection.  This is the first step: no file descriptor for the
callback functions forEachSong() and forEachDir().  If a callback
needs the file descriptor, it has to be passed in the void*data
pointer somehow; some callbacks might need a new struct for passing
more than one parameter.  This might look a bit cumbersome right now,
but our goal is to have a clean API.