project: rtp.jitter
owner: alpartis@thundernet.com
license: MIT open source
Coding style/standards guidelines are important. The standards that
will be enforced are summarized as follows:
1. indent with 4 spaces (no tabs allowed)
2. Unix line endings
3. NO Hungarian notation
With exceptions noted above, standards for this project follow much
of Linux kernel and Google guidelines:
https://www.kernel.org/doc/Documentation/CodingStyle
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
helpful commentary on this topic:
http://www.linuxjournal.com/article/5780
http://thundernet.com/alanpartis/articles/standards.shtml
-----
design discussion:
this is a jitter buffer for RTP packets based on C++11 and STL.
Memory management is something to be wary of; we will store our own
pointer to given packets in our buffer and will return copies of these
pointers when packets are popped off the buffer. In the case of a
buffer reset, or similar activity, we will go ahead and delete any
packets in our buffer at the time.
This implementation assumes that it is operating in a multi-threaded
environment and syncronizes all operations/methods.
Requirements:
R0: eliminate effects of jitter in RTP packet arrival
R1: detect and track missing packets in RTP stream
R2: allow configuration of depth and packet size (in milliseconds)
R3: track and report ongoing jitter stats:
dropped packets
out of order packets
missed packets
jitter (lifetime)
max jitter (lifetime)
current depth
The RTPJitter will manage an internal buffer of RTP frames. The application
layer adds and removes packets from this buffer through the .push() and
.pop() interface. It is up to the application to manage and schedule this
process on its own thread.
A jitter buffer introduces a configured delay in the delivery and
processing of packets; this is the "depth" in milliseconds of the buffer.
Once the first packet is received into an empty buffer, the "depth" timer
starts. Once it expires, packets will be delivered upon request in the
.pop() function until the buffer becomes empty again.
The remaining logic involves how to handle newly arriving packets and
handle the exception cases: missing or out-of-order packets. ... and how
to detect and address jitter.
Jitter will be calculated as the mean deviation from the expected based on
details, definitions, and sample code from RFC3550 section 6.4.1 and
Appendix A.8.
The jitter buffer will not examine, or differentiate, packets based on SSRC.
note 1 - we use a std::deque to implement the internal buffer because it
allows us to ignore the details of memory management for the buffer
as it may grow and shrink.