This variable doesn't have a role since 80799fa8.

On some platforms, g_free() must be used for memory allocated by
GLib.  This patch intends to correct a lot of occurrences, but is
probably not complete.

All config_get_block_*() functions should accept constant config_param
pointers.

config_get_string() is easier to use than config_get_param() because
it unpacks the config_param struct.

Added all important id tags from the MusicBrainz wiki:

 http://musicbrainz.org/doc/MusicBrainzTag

This should automatically enable its suport in the vorbis and flac
decoder plugins.

Renamed functions, types, variables.

Added TAG_ITEM_ALBUM_ARTIST.

With this patch, MPD should be able to read the (inofficial)
"ALBUMARTIST" Vorbis comment.  Implementations in other decoder
plugins will follow soon.

Use g_strndup() instead of g_memdup().

Pass NULL instead of &error to g_convert().  We're not interested in
the error object.

tag_merges() merges the data from two tag objects into one.

Don't use g_strescape(), because it escapes all non-ASCII characters.
Add a new function which clears all non-printable characters, not just
"newline".

This always allocates strings on the heap, but we can delete the
stripReturnChar() function now.

tag_has_type() checks whether the tag contains one or more items with
the specified type.

Don't use the deprecated functions from utils.h.

Eliminate code already provided by GLib.

Return NULL instead of the input value if there is nothing to fix.
This way, the caller doesn't have to use the xfree() hack.

Removed duplicated code.

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

avoid some redundant clearing logic as well, since the tag is
getting freed.

Seeing the "mpd_" prefix _everywhere_ is mind-numbing as the
mind needs to retrain itself to skip over the first 4 tokens of
a type to get to its meaning.  So avoid having extra characters
on my terminal to make it easier to follow code at 2:30 am in
the morning.

Please report any new issues you may come across on Free
toolchains.  I realize how difficult it can be to build/maintain
cross-compiling toolchains and I have no intention of forcing
people to upgrade their toolchains to build mpd.

Tested with gcc 2.95.4 and and gcc 4.3.1 on x86-32.

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.

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.

Move everything which dumps a tag to a file descriptor to tag_print.c.
This relaxes dependencies and splits the code into smaller parts.

clearMpdTag could be called on a tag that was still in a
tag_begin_add transaction before tag_end_add is called.  This
was causing free() to attempt to operate on bulk.items; which is
un-free()-able.  Now instead we unmark the bulk.busy to avoid
committing the tags to the heap only to be immediately freed.

Additionally, we need to remember to call tag_end_add() when
a song is updated before we NULL song->tag to avoid tripping
an assertion the next time tag_begin_add() is called.

Don't call tag_pool_get_item() for duplicating tags, just increase the
item's reference counter instead.

Yet another patch which converts pointer arguments to "const".

If many tag_items are added at once while the tag cache is being
loaded, manage these items in a static fixed list, instead of
reallocating the list with every newly created item.  This reduces
heap fragmentation.

Massif results again:

 mk before:  total 12,837,632; useful 10,626,383; extra 2,211,249
 mk now:     total 12,736,720; useful 10,626,383; extra 2,110,337

The "useful" value is the same since this patch only changes the way
we allocate the same amount of memory, but heap fragmentation was
reduced by 5%.

Try to detect if the string needs Latin1-UTF8 conversion, or
whitespace cleanup.  If not, we don't need to allocate temporary
memory, leading to decreased heap fragmentation.

Same as the previous patch, prepare the function fix_utf8() this time.

At several places, we create temporary copies of non-null-terminated
strings, just to use them in functions like validUtf8String().  We can
save this temporary allocation and avoid heap fragmentation if we
add a length parameter instead of expecting a null-terminated string.

We must never pass value==NULL to fix_utf().  Replace the run-time
check with an assertion.

Since the inline function cannot modify its caller's variables (which
is a good thing for code readability), the new string pointer is the
return value.  The resulting binary should be the same as with the
macro.

The new source tag_pool.c manages a pool of reference counted tag_item
objects.  This is used to merge tag items of the same type and value,
saving lots of memory.  Formerly, only the value itself was pooled,
wasting memory for all the pointers and tag_item structs.

The following results were measured with massif.  Started MPD on
amd64, typed "mpc", no song being played.  My music database contains
35k tagged songs.  The results are what massif reports as "peak".

 0.13.2:     total 14,131,392; useful 11,408,972; extra 2,722,420
 eric:       total 18,370,696; useful 15,648,182; extra 2,722,514
 mk f34f694e: total 15,833,952; useful 13,111,470; extra 2,722,482
 mk now:     total 12,837,632; useful 10,626,383; extra 2,211,249

This patch set saves 20% memory, and does a good job in reducing heap
fragmentation.

The value is stored in the same memory allocation as the tag_item
struct; this saves memory because we do not store the value pointer
anymore.  Also remove the getTagItemString()/removeTagItemString()
dummies.

This prepares the following patches, which aim to reduce MPD's memory
usage: we plan to share tag_item instances, instead of just their
values.

The ID3 code uses only the public tag API, but is otherwise
unrelated.  Move it to a separate source file.