Add RSID-based demuxing to RtpDemuxer

webrtc/call/rtp_demuxer.cc

 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/checks.h"
 #include "webrtc/call/rtp_demuxer.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 
 namespace webrtc {
 
 namespace {
 
+constexpr size_t kMaxProcessedSsrcs = 1000;  // Prevent memory overuse.
+
 template <typename Key, typename Value>
 bool MultimapAssociationExists(const std::multimap<Key, Value>& multimap,
                                Key key,
                                Value val) {
   auto it_range = multimap.equal_range(key);
   using Reference = typename std::multimap<Key, Value>::const_reference;
   return std::any_of(it_range.first, it_range.second,
                      [val](Reference elem) { return elem.second == val; });
 }
 
+template <typename Key, typename Value>
+size_t RemoveFromMultimapByValue(std::multimap<Key, Value*>& multimap,

[danilchap, 2017/06/07 13:45:42]

Pass by pointer.
"All parameters passed by reference must be labeled const."
https://google.github.io/styleguide/cppguide.html#Reference_Arguments

[eladalon, 2017/06/07 19:30:00]

Done.

+                                 const Value* value) {
+  size_t count = 0;
+  for (auto it = multimap.begin(); it != multimap.end();) {
+    if (it->second == value) {
+      it = multimap.erase(it);
+      ++count;
+    } else {
+      ++it;
+    }
+  }
+  return count;
+}
+
 }  // namespace
 
 RtpDemuxer::RtpDemuxer() {}
 
 RtpDemuxer::~RtpDemuxer() {
   RTC_DCHECK(sinks_.empty());
 }
 
 void RtpDemuxer::AddSink(uint32_t ssrc, RtpPacketSinkInterface* sink) {
+  RecordSsrcToSinkAssociation(ssrc, sink);
+}
+
+void RtpDemuxer::AddSink(const std::string& rsid,
+                         RtpPacketSinkInterface* sink) {
+  RTC_DCHECK(StreamId::IsLegalName(rsid));
   RTC_DCHECK(sink);
-  RTC_DCHECK(!MultimapAssociationExists(sinks_, ssrc, sink));
-  sinks_.emplace(ssrc, sink);
+  RTC_DCHECK(!MultimapAssociationExists(rsid_sinks_, rsid, sink));
+
+  rsid_sinks_.emplace(rsid, sink);
+
+  // This RSID might now map to an SSRC which we saw earlier.
+  processed_ssrcs_.clear();
 }
 
 size_t RtpDemuxer::RemoveSink(const RtpPacketSinkInterface* sink) {
   RTC_DCHECK(sink);
-  size_t count = 0;
-  for (auto it = sinks_.begin(); it != sinks_.end(); ) {
-    if (it->second == sink) {
-      it = sinks_.erase(it);
-      ++count;
-    } else {
-      ++it;
-    }
+  return RemoveFromMultimapByValue(sinks_, sink) +
+         RemoveFromMultimapByValue(rsid_sinks_, sink);
+}
+
+void RtpDemuxer::RecordSsrcToSinkAssociation(uint32_t ssrc,
+                                             RtpPacketSinkInterface* sink) {
+  RTC_DCHECK(sink);
+  // The association might already have been set by a different
+  // configuration source.
+  if (!MultimapAssociationExists(sinks_, ssrc, sink)) {
+    sinks_.emplace(ssrc, sink);
   }
-  return count;
 }
 
 bool RtpDemuxer::OnRtpPacket(const RtpPacketReceived& packet) {
-  bool found = false;
+  FindSsrcAssociations(packet);

[danilchap, 2017/06/07 13:45:42]

I wonder if it will be better to do like this instead of using processed_ssrc:
auto it_range = sinks_.equal_range(ssrc);
if (it_range.empty()) {
  if (!FindSsrcAssociations(packet))
    return;
  it_range = sinks_.equal_range(ssrc);
}

// Returns true if new ssrc assosiation was descovered and created.
bool FindSsrcAssosiations() {
}

[eladalon, 2017/06/07 19:30:00]

Discussed offline; keeping as is. One point, in case we forget the discussion
and return to it in the future - associations might exist for both an SSRC and
RSID. If we don't examine extra associations on the packet because we've marked
the SSRC as known, we won't find the other sinks which might be mapped to the
same SSRC via an RSID.

   auto it_range = sinks_.equal_range(packet.Ssrc());
   for (auto it = it_range.first; it != it_range.second; ++it) {
-    found = true;
     it->second->OnRtpPacket(packet);
   }
-  return found;
+  return it_range.first != it_range.second;
+}
+
+void RtpDemuxer::FindSsrcAssociations(const RtpPacketReceived& packet) {
+  // Avoid expensive string comparisons for RSID by looking the sinks up only
+  // by SSRC whenever possible.
+  if (processed_ssrcs_.find(packet.Ssrc()) != processed_ssrcs_.cend()) {
+    return;
+  }
+
+  // RSID-based associations:
+  std::string rsid;
+  if (packet.GetExtension<RtpStreamId>(&rsid)) {
+    // All streams associated with this RSID need to be marked as associated
+    // with this SSRC (if they aren't already).
+    auto it_range = rsid_sinks_.equal_range(rsid);
+    for (auto it = it_range.first; it != it_range.second; ++it) {
+      RecordSsrcToSinkAssociation(packet.Ssrc(), it->second);
+    }
+
+    // To prevent memory-overuse attacks, forget this RSID. Future packets
+    // with this RSID, but a different SSRC, will not spawn new associations.
+    rsid_sinks_.erase(it_range.first, it_range.second);
+  }
+
+  if (processed_ssrcs_.size() < kMaxProcessedSsrcs) {  // Prevent memory overuse
+    processed_ssrcs_.insert(packet.Ssrc());  // Avoid re-examining in-depth.
+  }
 }
 
 }  // namespace webrtc