RFC 6555 "Happy Eyeballs" has a few recommendations for
 implementing dual requests to hosts with both IPv4 and IPv6 DNS
 entries that differ slightly from how we used to do it.
This commit updates things to follow those recommendations.

Otherwise redirects we'll stuff two requests into the same buffer
 if there's a redirect to another https URL via a proxy.

This separates the state for whether pipelining might be supported
 (HTTP 1.1 responses with a Server header) and for whether it's
 been explicitly disabled (Server headers from known-bad servers).
This does a better job with repeated (and possibly contradictory)
 headers.

This provides a fallback commit id if no tags are available,
for example when doing a shallow clone.

For many Latin1 characters this still worked correctly by pure luck.
Unfortunately, that included my test case.

It was only guaranteed to work in the seekable case.
Thanks to Radio Stadtfilter 96.3Mhz for sending a stream which
 triggered this failure.

All the actual filters are named op_foo_filter(), so
 op_read_native_filter() looked like another one.
Changing the word order should remove the ambiguity.

Don't know if this actually leads to any better code generation,
 but it may make the code a little clearer.

This makes it clear they don't modify the state, which is a useful
 indicator of what is safe to call from the application decode
 callback.

Otherwise we would have failed to open the stream.

This is a little easier to read, and allows us to save some
 subtractions and a comparison.

The increasingly-inaccurately named op_shaped_dither16() can serve
 this role instead, without much additional complexity (perhaps
 less, once you consider the required shuffling around of the
 function parameters).

This is to correspond to the feature in opus-tools's opusdec.
opusdec itself probably won't be able to use it, because it still
 wants to do dithering after resampling, but the motivation for the
 feature is the same.

Previously I'd said this would require a large stack buffer, which
 was true if you simply wanted to re-use the existing
 op_short2float_filter() and floating-point op_stereo_filter().
But the latter is not normally compiled for fixed-point anyway, so
 we can instead write new code that doesn't need the stack buffer
 without harming anything.

These were unlikely when I originally expected applications to
 normally provide a decode buffer in the right format of sufficient
 size.
However, the decode filter API works by asking to decode into a
 0-byte buffer, which will trigger both of these tests on every
 packet.
Since this is how three of the four decoding APIs are implemented,
 this is not really that unlikely anymore.

This makes op_fetch_and_process_page() always try to fetch another
 page, like it used to (and like its name implies).
There was only one place where we needed the early return for
 unprocessed packets, and getting rid of that actually simplifies
 the logic there (replacing a conditional continue with an
 unconditional one in a slightly different location).

This is needed to allow advanced usage, like that of opusdec in
 opus-tools, which can simulate packet loss or save the range coder
 state for decoder verification.
It could also be used in a pinch to use libopusfile for access to
 the raw Ogg packets, though this is somewhat of a hack.

Also refactor the other tag functions to centralize the memory
 allocation logic, plus a few other minor cleanups.

It seems somewhat silly to have to write your own strcasecmp to
 satisfy the usage pattern found in opusfile_example: scanning the
 whole tags list and handling certain tags specially (as opposed to
 searching for specific tags, as opus_tags_query() does).
Given that we were already using an equivalent function internally
 to implement opus_tags_query, just expose it directly.

OP_INT32_MIN and OP_INT32_MAX were added in commit 97917914.
This fixes at least one bug, since one of the (extremely unlikely)
 overflow checks had an extra F in it.

Mostly minor stuff.

This allows the application to report details about the server for
 HTTP[S] streams.
For all HTTP[S], this includes the server software, content-type,
 and whether or not it's using HTTPS.
For live streams, it also includes the station name, description,
 genre, homepage, nominal bitrate, and whether or not it's publicly
 listed.

This was treating every unknown header as a Server header.
Good thing this was last!
The only damage was that we might have enabled pipelining even on
 known-bad servers.

I guess no one was using these.
Clearly we need to test this more often, but this is a pain without
 a reliable public proxy, or a local proxy server setup.

These were only non-static because of oversight.

Finally managed to cross-compile a shared version of openssl
so I can use the autotools opusfile build.

We've added opus_picture_tag.

This lets us pick up runtime library path changes when the project
files are updated to newer versions on Visual Studio. This fixes
a link error with VS2012, but I still get one from VS2010.

Windows still doesn't support tar.gz out of the box. If we're
bothering with project files we might as well make it easy
to get the source releases.

Surprisingly, the actual initial value of this variable is
 irrelevant, since we always insert 24 bits of data into and then
 read only those bits out.
However, fixing this still removes undefined behavior and removes
 extraneous register dependencies.

- Reject 'not a character' values 0xFFFE and 0xFFFF.
- Remove some unnecessary string length checks.

This makes it easier for applications to support album art.
This is still relatively untested.

Incremental linking fails on my unpatched VS2010 compiler
with "failure during conversion to COFF: file invalid or corrupt".
Other than testing both configurations there's no particular
reason to use the option here.