RTCP support

[gavv]

RFC 3550 requires conforming implementations to provide RTCP support. In fact, roc can function without it, though RTCP provides some benefits:

• without RTCP, sender has no feedback from receiver; it even doesn't know, if receiver was able to receive traffic, if receiver was able to process the traffic and didn't reject it for some reason, and if quality of service is acceptable;
• RTCP allows receiver to detect associated streams from single sender in a standard-conforming way, e.g. audio stream and FEC stream (we're now using an ad-hoc implementation that conforms to no standard);
• RTCP provides timing synchronisation for sender and receiver and for several streams of single sender (e.g. audio and video);
• RTCP can be used to implement dynamic adjustment of latency and FEC code rate (using RFC 5725);
• RTCP can be used to implement retransmission using RFC 4588 and RFC 4585;
• RTCP allows multiple senders to share the same source transport address (e.g. in case of RTP translator);
• RTCP allows seamless sender restart or address change (this also allows sender roaming);
• RTCP allows receiver to terminate sender's session immediately without waiting for timeout;
• RTCP is used in RTSP, which we may want to support in future;
• with RTCP, receiver sends to sender various statistics that may be useful for troubleshooting, especially when receiver is some embedded device which is harder to debug;
• some senders may reject connection if there is no RTCP feedback from receiver (I'm not aware of such senders however);
• finally, RTCP also allows to exchange arbitrary application-specific data.

RTCP consists of the following message types:

• SR (sender report): statistics sent from sender to receiver;
• RR (receiver report): statistics and feedback send from receiver to sender;
• SDES (source description items): sender identification sent from sender to receiver;
• BYE: session termination, initiated by sender or receiver;
• APP: arbitrary application-specific data.

[gavv]

Related RFCs

RTCP and SDP:

• https://tools.ietf.org/html/rfc3605
• https://tools.ietf.org/html/rfc3556
• https://tools.ietf.org/html/rfc3890

Multiplexing RTP and RTCP:

• https://www.rfc-editor.org/rfc/rfc5761
• https://www.rfc-editor.org/rfc/rfc8035

RTP/AVPF and XRs:

• https://tools.ietf.org/html/rfc4585
• https://tools.ietf.org/html/rfc5725

RTCP and security / encryption:

• https://tools.ietf.org/html/rfc7022
• https://tools.ietf.org/html/rfc5124

[gavv]

Steps

Implement components

• rtcp::Parser
• rtcp::Composer
• rtcp::Builder
• rtcp::Traverser
• rtcp::XrTraverser
• rtcp::SdesTraverser
• rtcp::ByeTraverser
• rtcp::IStreamController
• rtcp::Reporter
• rtcp::Communicator (process and generates packets)
• rtcp::RttEstimator (estimates RTT based on XR)

Refine error handling

• instead of INVALID state, keep only END state and add bool error() getter to check if there were errors; this will make user code less bug prone - the last state is always END
• if we skip some packet/chunk/block, we should set error flag so that the user can check it with bool error() getter; this should be done in all traverser
• when we skip something, we should allow to continue to next item, don't fail instantly, so that the user could parse everything that is parsable

Support padding

• RTCP traverser: remove padding
• RTCP builder: pad last packet in compound

Refine test coverage

• unknown RTCP packet type
• unknown XR blocks
• zero blocks (RR, SR, XR)
• zero sub-blocks (XR DLRR)
• zero chunks, zero items (SDES)
• zero sources (BYE)
• empty strings (SDES item, BYE reason)
• multiple SDES chunks
• test for various invalid packets
• tests for padding

Integration into pipeline

• teach receiver to send packets
• teach sender to receive packets
• teach netio to share port for receiving and sending
• receiver: implement rtcp::IStreamController
• receiver: query reports from sessions (multiple streams per each session)
• receiver: pass reports to sessions
• receiver: session routing based on RTCP
• receiver: associate streams based on SDES CNAME messages
• receiver: terminate sessions based on BYE messages
• sender: implement rtcp::IStreamController
• sender: query report from pipeline
• sender: pass report to pipeline

Reports checklist

• receiver: fully fill RR/XR
• receiver: fully handle SR/XR
• sender: fully fill SR/XR
• sender: fully handle RR/XR

Packet handling checklist

• SDES: generate (on sender and receiver)
• SDES: process (on sender and receiver)
• BYE: generate (on sender and receiver)
• BYE: process (on sender and receiver)
• SR, DLRR: generate (on sender)
• SR, DLRR: process (on receiver)
• RR, RRTR: generate (on receiver)
• RR, RRTR: process (on sender)

API and CLI

• Extend the public API. Add control port type and RTCP protocol. Allow to bind and connect receiver and sender to control ports. Allow to bind sender to different source and repair ports.
• Add RTCP port to command-line tools.
• Support two-way control packet exchange in roc_sender_encoder & roc_receiver_decoder

High-level tests

• rtcp communicator
• pipeline
• public_api

[gavv]

Done.