Thanks to Greg for pointing out I'd missed this.

This avoids linker errors with VS2010 of the form
    failure during conversion to COFF: invalid file or corrupt
    [c:\users\giles\opus\source\opus_demo.vcxproj]

The problem does not occur if the project files are updated
to build under VS2012.

This must be updated in sync with the version numbers in
configure.ac.

The autotools build strips the initial 'v' from release
tags, but genversion.bat does not, so I've left it in
the static version.h to match what would be generated
when building from the git tag.

This is a dependency of libopus.

The option was added primarily for multistream debugging. I don't believe anyone
 is currently using it, but I'll leave it in for now for compatibility and because
 my own test scripts use it.

Uncouplued is not something people should normally be setting as it results in
 lower quality streams which are gratuitously RTP incompatible.

Opusenc was using ftell() whos return is 32 bits on some systems to get the
 input file size and later code was not dealing well with negative sizes.
This commit changes to use 64-bit returning functions where available and
 sanity checks the detected length then treats any cases where the length
 still ends up negative as streams.

Thanks to win32vb on IRC for the report and reproduction.

Passing 'enable' as an argument to AM_MAINTAINER_MODE flips the
default to enabled, rather than disabled until automake 1.11.
This is a safer default for a developer-oriented library.

./configure --disable-maintainer-mode is still available for
packagers who what to preserve the upstream build distribution.

On earlier automake versions, the argument appears to have no
effect, so there is no behaviour change for developers using
older autotools.

Based on a patch for opusfile by ron@debian.org.

This lets it compile (but not be functional) on Windows,
which doesn't support the posix socket api.

If $(CC) contains the substring 'mingw' then add some
options required to target windows. This fixes

  make -f Makefile.unix CC=i686-w64-mingw32-gcc

on my Fedora 17 system.

This uses a few more GNU make features, and makes the
Makefile itself less portable. However, we've had some
gnu-isms like := for a couple of releases so far without
complaint.

We don't need the union, we can memcpy directly into an int.
NB this assumes at least a 32 bit int, since the actual header
field is 32 bits.

Also minor related comment updates

Arm (and other) architectures have stricter alignment requirements
thank x86, so just casting a char* to an int* and reading from it
could cause an exception, and because of this gcc warns on that
platform.

I'm pretty sure this particular read would always be aligned in
pracice, since it's the first word of the network packet returned
by pcap, but adding a more general helper is reasonable.

We memcpy() the value into a union, which the compiler should
allocate aligned, and then read the data back out as an int.

Thanks to Ron for reporting the issue, and Greg for suggesting
the fix.

Getting 64kbit/sec output for a mono 8kHz stream is somewhat surprising.
Instead lower the default rate by a factor of (rate+16000)/64000 for rates
under 44.1kHz. This gives mono 8kHz a more respectable 24kbit/sec rate.

In opusenc the "encoding complete" was incompletely overwriting
the last status line. Now it takes care to overwrite it all the way.

I don't know what I was thinking, but 'i' wasn't the variable
I wanted to be shifting the argument list by.

This will help encoder/streamer implementations that have it wrong
detect their mistake a little earlier.

This matches the value used by the webrtc.org codebase now that
the basic support patch has been merged.

gcc 4.7.2's -Wshadow can't tell types from variable names.

Helps debug duration-related issues.

Also update the usage and manpage for the send functionality.

Previously, everything was hard-coded to 20 ms. Now we increment
rtp timestamps and ogg granulepos based on the packet duration
as described by the ToC header.

This adds a dependency on libopus, but the opus_packet() calls
as small and can stand alone, so they could be extracted and
supplied separately if necessary.

Granulepos values are still ignored when reading from a .opus
file. It would probably be better to either warn, or use those
as much as possible to set the rtp timestamps to better represent
the recorded data.

Previously, the length passed to the sendto() function didn't
include the length of the rtp header, truncating every packet
by 12 bytes.

Also use the calculated rtp header size, rather than hard-coding
the minimum size.

Previously we were sending version 0, which the webrtc.org
code rightly rejects.

Corrects a crash when rtpdump.opus exists, but isn't valid data.

Instead of using compile-time switches to choose loopback
or eth header parsing in sniff mode, ask libpcap what it
will be supplying and parse based on that.

Also abort if the link layer type isn't ethernet or loopback,
or if the header doesn't indicate IP/UDP.

This returns the proper value (2) on darwin, matching socket.h:
  #define AF_INET 2 /* internetwork: UDP, TCP, etc. */

On darwin, pcap returns packets from the loopback device
with a 4 byte 'family' number, instead of the dummy eth
header we get on linux. Add support for parsing this
instead. The build now needs to define either 'LOOP' or
'ETH' to control which is expected.

I don't know if there's a way to ask pcap about this,
but wireshark manages to handle it correctly.

Also hardcode the sniff device to 'lo0' as required by
darwin instead of linux 'lo'. That's where I'm currently
testing.

This lets us use the same value in the sniff and send functions.

Otherwise we fall through to the default sending behaviour.

This sends the file 'rtpdump.opus' over rtp. Host and port are
hard-coded to 127.0.0.1:1234, payload type 109, 20 ms packets.

Start of rtp packet send support.

Andreas Schlick authored 12 years ago and Gregory Maxwell committed 12 years ago

cpusupport.h used __cpuid() from the Windows specific header file intrin.h
which is not available under gcc. But we can use __get_cpuid() from cpuid.h
instead.