* Tags were being freed even if not initialized if
   op_fetch_headers() failed on the first link.
  The logic for handling completely empty links would leak, also.
* Ignore fragment identifiers in http URLs instead of rejecting
   them.
* Get the current link in seeking_example's verify_seek when
   op_read_native() fails to return it for us.

Most of these were dead code left around from rewriting things and
 things llvm doesn't have enough global information to prove by
 itself.
The one real error was the missing NULL check in
 opus_tags_parse_impl().

Also use Libs.private for libm.

This displays the current raw position, PCM position, and
 instantaneous bitrate once per second of output.
This is useful when testing against long-running streams.

This makes it more useful for testing invalid files, where the goal
 is merely not to crash, assert, or trip valgrind warnings.

* Add Opus logo.
* Use @VERSION@ consistently.
* Fix some warnings/formatting exposed by a newer Doxygen versions.

The warning was correct, as far as it goes, but the use was
 actually harmless.

The previous comparison would have succeeded on things like
 "localhost123" instead of just "localhost".

* Guarantee pcm_start and pcm_end stay in range (not just move in
   the right direction).
* When we fail to find a page in the interval, back up by increasing
   chunk sizes just like op_get_prev_page_serial().
* Eliminate the special case for the last page in the interval.
* Force a straight bisection if we're backing up, but not decreasing
   the interval size rapidly enough, to limit the worst-case.
  This is guaranteed not to affect the first two iterations, so it
   has minimal impact on seeking in the normal case.

The autoconf build replaced the static Doxyfile with a Doxyfile.in
template. In the autoconf build, the config.status script applies
substitutions to generate the actual Doxyfile. This made the generic
doc/Makefile non-functional.

Apply similar substitutions directly with the makefile so we can
still build documentation outside the context of the autoconf build.

Also add a 'distclean' target to remove the generated Doxyfile.

We have to call op_collect_audio_packets() again to drain any
 buffered packets from the page.

Diego Elio Pettenò authored 12 years ago and Timothy B. Terriberry committed 12 years ago

Includes
- A make debug target that disables optimizations and enables
   assertions,
- Proper ./configure switches for the optional features,
- A configuration summary,
- libtool versioning information,
- Visibility and warning flags,
- API documentation, and
- Support for out-of-tree builds.

Signed-off-by: Diego Elio Pettenò <flameeyes@flameeyes.eu>

* s/op_read_stereo_float/op_read_float_stereo/ for the fixed-point
   API.
* Fix compiler warnings exposed when optimizations are enabled.
* Fix opusfile_example to work with --enable-fixed-point
   --disable-float
* Fix seeking_example to not re-define OP_FIXED_POINT if it's
   already been defined.

GNU make provides a default definition for this variable.

I've no idea what's special about mingw32-ar vs native ar,
but it seems to be required.

The most important for the https backend:
- Implement RFC 6066 Server Name Indication.
- Implement SSL session resumption.
  This gives less of a speed improvement than you might think.

It's served its purpose, and isn't worth the time it takes now.
Leaving the code around to make it easy to re-enable if necessary.

Splits the documentation into sections and provides an overview.
Also explicitly document which functions can and cannot be called on
 partially-open streams, and fix-up a few things to behave as
 documented.

There are now a couple of places where we need to know the actual
 stream position indicator, not just the offset of the data we've
 read out of the ogg_sync_state.
Make a function to compute this, document it, and use it.

end_offset should be the _start_ of the last Opus page in a link,
 to guarantee we seek before it to have enough information to do
 end-trimming.
After the changes in 007ec4e4, it would be set to the start of the
 next link if we cached the last page granule position.

Also add more comments.

1) Remember the granule position of the last page we've seen from
    the current link and save the first page of the next link as
    long as we're scanning forward.
   This knocks almost 10% off the number of seeks for large links.
   For smaller links the improvement is much larger.
2) Only use pairs of close-by serial numbers to estimate link
    start locations (assuming they're above our start threshold).
   This gives a minor (<2%) improvement, which might be in the
    noise, but as it doesn't appear to hurt and is faster, might as
    well.
3) Eliminate a redundant check in op_pcm_seek_page_impl().

If we encounter the first page after the target while scanning
 forward, we no longer seek back and read it again after we exit the
 bisection search, but just hold on to the copy we already have.

Teach me to change something right before committing.

This gives us a better idea when to re-use a connection.

This uses two sightings of a valid granule position from the same
 future stream to extrapolate where the start of that stream is
 during link enumeration.
This can cut out more than 20% of the seeks required to open large
 files with lots of long links.

2df5f786 did not quite save enough.
The ogg_stream_state and initial ogg_packet list also need to be
 saved, and the starting granule position and pre-skip need to be
 restored.
Otherwise, if the stream has more than one link, the first packets
 decoded will come from the wrong one.

This means that in the normal case, after identifying the chain
 boundaries, we will seek back exactly where we were before.
With the http backend, that gives us a good chance of re-using our
 initial connection to continue reading the stream.
Currently the LRU connection expiration algorithm means that is
 unlikely with lots of links, however.

Try to guess that the next link will be approximately the average
 size of all previous links, for files with many links.
This cuts off 6-17% of the seeks.

Also remove a variable that was left unused after 5e36109d.

Reduce the number of places we modify 'offset' so that
 op_seek_helper() can always skip seeks to the current offset.
The checks we were doing before already covered all the places
 where this was useful in the normal case, but this lets us
 centralize that logic.

This commit also includes a few minor follow-ups to 9b57b0c2:
* Use a smaller type for ret_size and initialize it.
* Verify 'end' is at least as large as data we've already read.

1) We were treating EOF in op_get_next_page() as a read error when
    called from op_get_prev_page_serial().
2) We also assumed op_get_prev_page_serial() stopped scanning at the
    end of the page it returned, in order to compute the size of
    that page.
   Return the page size explicitly instead.
3) Finally, once we discover where the last page is, there is no
    reason to ever look at data past it.
   Update 'end' once we find it, and always pass that to
    op_get_next_page().

Actually close the old socket.
Don't initialize SSL more than once.

Also fixes some indenting in opusfile_example.

This is pretty preliminary for now.
Seeking performance isn't great, and there's no caching.
I'm sure there's also lots of bugs.