Add BUNDLE processing to RtpDemuxer.
Extends the RtpDemuxer to do demuxing according to the BUNDLE spec,
using MID and payload types in addition to RSID and SSRC. Also extends
SsrcBindingObserver to receive notification for all types of SSRC
binding that can occur with the new algorithm.
Bug: webrtc:4050
Change-Id: Ie2f347f90d5074ab537fa1162fa7314dd292b68b
Reviewed-on: https://chromium-review.googlesource.com/578628
Commit-Queue: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Reviewed-by: Peter Thatcher <pthatcher@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#19415}diff --git a/webrtc/call/rtp_demuxer.h b/webrtc/call/rtp_demuxer.h
index 702d787..ddd4a2f 100644
--- a/webrtc/call/rtp_demuxer.h
+++ b/webrtc/call/rtp_demuxer.h
@@ -12,7 +12,9 @@
#define WEBRTC_CALL_RTP_DEMUXER_H_
#include <map>
+#include <set>
#include <string>
+#include <utility>
#include <vector>
namespace webrtc {
@@ -21,16 +23,90 @@
class RtpPacketSinkInterface;
class SsrcBindingObserver;
+// This struct describes the criteria that will be used to match packets to a
+// specific sink.
+struct RtpDemuxerCriteria {
+ RtpDemuxerCriteria();
+ ~RtpDemuxerCriteria();
+
+ // If not the empty string, will match packets with this MID.
+ std::string mid;
+
+ // If not the empty string, will match packets with this as their RTP stream
+ // ID or repaired RTP stream ID.
+ // Note that if both MID and RSID are specified, this will only match packets
+ // that have both specified (either through RTP header extensions, SSRC
+ // latching or RTCP).
+ std::string rsid;
+
+ // Will match packets with any of these SSRCs.
+ std::set<uint32_t> ssrcs;
+
+ // Will match packets with any of these payload types.
+ std::set<uint8_t> payload_types;
+};
+
// This class represents the RTP demuxing, for a single RTP session (i.e., one
-// ssrc space, see RFC 7656). It isn't thread aware, leaving responsibility of
+// SSRC space, see RFC 7656). It isn't thread aware, leaving responsibility of
// multithreading issues to the user of this class.
-// TODO(nisse): Should be extended to also do MID-based demux and payload-type
-// demux.
+// The demuxing algorithm follows the sketch given in the BUNDLE draft:
+// https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-38#section-10.2
+// with modifications to support RTP stream IDs also.
+//
+// When a packet is received, the RtpDemuxer will route according to the
+// following rules:
+// 1. If the packet contains the MID header extension, and no sink has been
+// added with that MID as a criteria, the packet is not routed.
+// 2. If the packet has the MID header extension, but no RSID or RRID extension,
+// and the MID is bound to a sink, then bind its SSRC to the same sink and
+// forward the packet to that sink. Note that rebinding to the same sink is
+// not an error. (Later packets with that SSRC would therefore be forwarded
+// to the same sink, whether they have the MID header extension or not.)
+// 3. If the packet has the MID header extension and either the RSID or RRID
+// extension, and the MID, RSID (or RRID) pair is bound to a sink, then bind
+// its SSRC to the same sink and forward the packet to that sink. Later
+// packets with that SSRC will be forwarded to the same sink.
+// 4. If the packet has the RSID or RRID header extension, but no MID extension,
+// and the RSID or RRID is bound to an RSID sink, then bind its SSRC to the
+// same sink and forward the packet to that sink. Later packets with that
+// SSRC will be forwarded to the same sink.
+// 5. If the packet's SSRC is bound to an SSRC through a previous call to
+// AddSink, then forward the packet to that sink. Note that the RtpDemuxer
+// will not verify the payload type even if included in the sink's criteria.
+// The sink is expected to do the check in its handler.
+// 6. If the packet's payload type is bound to exactly one payload type sink
+// through an earlier call to AddSink, then forward the packet to that sink.
+// 7. Otherwise, the packet is not routed.
+//
+// In summary, the routing algorithm will always try to first match MID and RSID
+// (including through SSRC binding), match SSRC directly as needed, and use
+// payload types only if all else fails.
class RtpDemuxer {
public:
+ // Maximum number of unique SSRC bindings allowed. This limit is to prevent
+ // memory overuse attacks due to a malicious peer sending many packets with
+ // different SSRCs.
+ static constexpr int kMaxSsrcBindings = 1000;
+
RtpDemuxer();
~RtpDemuxer();
+ RtpDemuxer(const RtpDemuxer&) = delete;
+ void operator=(const RtpDemuxer&) = delete;
+
+ // Registers a sink that will be notified when RTP packets match its given
+ // criteria according to the algorithm described in the class description.
+ // Returns true if the sink was successfully added.
+ // Returns false in the following situations:
+ // - Only MID is specified and the MID is already registered.
+ // - Only RSID is specified and the RSID is already registered.
+ // - Both MID and RSID is specified and the (MID, RSID) pair is already
+ // registered.
+ // - Any of the criteria SSRCs are already registered.
+ // If false is returned, no changes are made to the demuxer state.
+ bool AddSink(const RtpDemuxerCriteria& criteria,
+ RtpPacketSinkInterface* sink);
+
// Registers a sink. Multiple SSRCs may be mapped to the same sink, but
// each SSRC may only be mapped to one sink. The return value reports
// whether the association has been recorded or rejected. Rejection may occur
@@ -46,11 +122,12 @@
// Null pointer is not allowed.
bool RemoveSink(const RtpPacketSinkInterface* sink);
- // Handles RTP packets. Returns true if at least one matching sink was found.
+ // Demuxes the given packet and forwards it to the chosen sink. Returns true
+ // if the packet was forwarded and false if the packet was dropped.
bool OnRtpPacket(const RtpPacketReceived& packet);
- // Allows other objects to be notified when RSID-SSRC associations are
- // resolved by this object.
+ // The Observer will be notified when an attribute (e.g., RSID, MID, etc.) is
+ // bound to an SSRC.
void RegisterSsrcBindingObserver(SsrcBindingObserver* observer);
// Deprecated: Use the above method.
void RegisterRsidResolutionObserver(SsrcBindingObserver* observer);
@@ -61,21 +138,61 @@
void DeregisterRsidResolutionObserver(const SsrcBindingObserver* observer);
private:
- // Find the associations of RSID to SSRCs.
- void ResolveRsidToSsrcAssociations(const RtpPacketReceived& packet);
+ // Returns true if adding a sink with the given criteria would cause conflicts
+ // with the existing criteria and should be rejected.
+ bool CriteriaWouldConflict(const RtpDemuxerCriteria& criteria) const;
- // Notify observers of the resolution of an RSID to an SSRC.
- void NotifyObserversOfRsidResolution(const std::string& rsid, uint32_t ssrc);
+ // Runs the demux algorithm on the given packet and returns the sink that
+ // should receive the packet.
+ // Will record any SSRC<->ID associations along the way.
+ // If the packet should be dropped, this method returns null.
+ RtpPacketSinkInterface* ResolveSink(const RtpPacketReceived& packet);
- // This records the association SSRCs to sinks. Other associations, such
- // as by RSID, also end up here once the RSID, etc., is resolved to an SSRC.
- std::map<uint32_t, RtpPacketSinkInterface*> ssrc_sinks_;
+ // Used by the ResolveSink algorithm.
+ RtpPacketSinkInterface* ResolveSinkByMid(const std::string& mid,
+ uint32_t ssrc);
+ RtpPacketSinkInterface* ResolveSinkByMidRsid(const std::string& mid,
+ const std::string& rsid,
+ uint32_t ssrc);
+ RtpPacketSinkInterface* ResolveSinkByRsid(const std::string& rsid,
+ uint32_t ssrc);
+ RtpPacketSinkInterface* ResolveSinkByPayloadType(uint8_t payload_type,
+ uint32_t ssrc);
- // A sink may be associated with an RSID - RTP Stream ID. This tag has a
- // one-to-one association with an SSRC, but that SSRC is not yet known.
- // When it becomes known, the association of the sink to the RSID is deleted
- // from this container, and moved into |ssrc_sinks_|.
- std::map<std::string, RtpPacketSinkInterface*> rsid_sinks_;
+ // Regenerate the known_mids_ set from information in the sink_by_mid_ and
+ // sink_by_mid_and_rsid_ maps.
+ void RefreshKnownMids();
+
+ // Map each sink by its component attributes to facilitate quick lookups.
+ // Payload Type mapping is a multimap because if two sinks register for the
+ // same payload type, both AddSinks succeed but we must know not to demux on
+ // that attribute since it is ambiguous.
+ // Note: Mappings are only modified by AddSink/RemoveSink (except for
+ // SSRC mapping which receives all MID, payload type, or RSID to SSRC bindings
+ // discovered when demuxing packets).
+ std::map<std::string, RtpPacketSinkInterface*> sink_by_mid_;
+ std::map<uint32_t, RtpPacketSinkInterface*> sink_by_ssrc_;
+ std::multimap<uint8_t, RtpPacketSinkInterface*> sinks_by_pt_;
+ std::map<std::pair<std::string, std::string>, RtpPacketSinkInterface*>
+ sink_by_mid_and_rsid_;
+ std::map<std::string, RtpPacketSinkInterface*> sink_by_rsid_;
+
+ // Tracks all the MIDs that have been identified in added criteria. Used to
+ // determine if a packet should be dropped right away because the MID is
+ // unknown.
+ std::set<std::string> known_mids_;
+
+ // Records learned mappings of MID --> SSRC and RSID --> SSRC as packets are
+ // received.
+ // This is stored separately from the sink mappings because if a sink is
+ // removed we want to still remember these associations.
+ std::map<uint32_t, std::string> mid_by_ssrc_;
+ std::map<uint32_t, std::string> rsid_by_ssrc_;
+
+ // Adds a binding from the SSRC to the given sink. Returns true if there was
+ // not already a sink bound to the SSRC or if the sink replaced a different
+ // sink. Returns false if the binding was unchanged.
+ bool AddSsrcSinkBinding(uint32_t ssrc, RtpPacketSinkInterface* sink);
// Observers which will be notified when an RSID association to an SSRC is
// resolved by this object.
