New class RtpDemuxer and RtpPacketSinkInterface, use in Call.

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
@@ skipping 16 matching lines @@
 #include "webrtc/base/logging.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/base/ptr_util.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call/bitrate_allocator.h"
 #include "webrtc/call/call.h"
 #include "webrtc/call/flexfec_receive_stream_impl.h"
+#include "webrtc/call/rtp_demuxer.h"
 #include "webrtc/call/rtp_transport_controller_send.h"
 #include "webrtc/config.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/receive_side_congestion_controller.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
@@ skipping 150 matching lines @@
   const std::unique_ptr<BitrateAllocator> bitrate_allocator_;
   Call::Config config_;
   rtc::ThreadChecker configuration_thread_checker_;
 
   NetworkState audio_network_state_;
   NetworkState video_network_state_;
 
   std::unique_ptr<RWLockWrapper> receive_crit_;
   // Audio, Video, and FlexFEC receive streams are owned by the client that
   // creates them.
-  std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_
-      GUARDED_BY(receive_crit_);
-  std::map<uint32_t, VideoReceiveStream*> video_receive_ssrcs_
+  std::set<AudioReceiveStream*> audio_receive_streams_
       GUARDED_BY(receive_crit_);
   std::set<VideoReceiveStream*> video_receive_streams_
       GUARDED_BY(receive_crit_);
-  // Each media stream could conceivably be protected by multiple FlexFEC
-  // streams.
-  std::multimap<uint32_t, FlexfecReceiveStreamImpl*>
-      flexfec_receive_ssrcs_media_ GUARDED_BY(receive_crit_);
-  std::map<uint32_t, FlexfecReceiveStreamImpl*>
-      flexfec_receive_ssrcs_protection_ GUARDED_BY(receive_crit_);
-  std::set<FlexfecReceiveStreamImpl*> flexfec_receive_streams_
-      GUARDED_BY(receive_crit_);
+
   std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
       GUARDED_BY(receive_crit_);
 
+  // TODO(nisse): Should eventually be part of injected
+  // RtpTransportControllerReceive, with a single demuxer in the bundled case.
+  RtpDemuxer audio_rtp_demuxer_ GUARDED_BY(receive_crit_);
+  RtpDemuxer video_rtp_demuxer_ GUARDED_BY(receive_crit_);
+
   // This extra map is used for receive processing which is
   // independent of media type.
 
   // TODO(nisse): In the RTP transport refactoring, we should have a
   // single mapping from ssrc to a more abstract receive stream, with
   // accessor methods for all configuration we need at this level.
   struct ReceiveRtpConfig {
     ReceiveRtpConfig() = default;  // Needed by std::map
     ReceiveRtpConfig(const std::vector<RtpExtension>& extensions,
                      bool use_send_side_bwe)
@@ skipping 136 matching lines @@
 
   pacer_thread_->Start();
 }
 
 Call::~Call() {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   RTC_CHECK(audio_send_ssrcs_.empty());
   RTC_CHECK(video_send_ssrcs_.empty());
   RTC_CHECK(video_send_streams_.empty());
-  RTC_CHECK(audio_receive_ssrcs_.empty());
-  RTC_CHECK(video_receive_ssrcs_.empty());
+  RTC_CHECK(audio_receive_streams_.empty());
   RTC_CHECK(video_receive_streams_.empty());
 
   pacer_thread_->Stop();
   pacer_thread_->DeRegisterModule(transport_send_->send_side_cc()->pacer());
   pacer_thread_->DeRegisterModule(
       receive_side_cc_.GetRemoteBitrateEstimator(true));
   module_process_thread_->DeRegisterModule(transport_send_->send_side_cc());
   module_process_thread_->DeRegisterModule(&receive_side_cc_);
   module_process_thread_->DeRegisterModule(call_stats_.get());
   module_process_thread_->Stop();
@@ skipping 121 matching lines @@
       config, config_.audio_state, &worker_queue_, transport_send_.get(),
       bitrate_allocator_.get(), event_log_, call_stats_->rtcp_rtt_stats());
   {
     WriteLockScoped write_lock(*send_crit_);
     RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) ==
                audio_send_ssrcs_.end());
     audio_send_ssrcs_[config.rtp.ssrc] = send_stream;
   }
   {
     ReadLockScoped read_lock(*receive_crit_);
-    for (const auto& kv : audio_receive_ssrcs_) {
-      if (kv.second->config().rtp.local_ssrc == config.rtp.ssrc) {
-        kv.second->AssociateSendStream(send_stream);
+    for (AudioReceiveStream* stream : audio_receive_streams_) {
+      if (stream->config().rtp.local_ssrc == config.rtp.ssrc) {
+        stream->AssociateSendStream(send_stream);
       }
     }
   }
   send_stream->SignalNetworkState(audio_network_state_);
   UpdateAggregateNetworkState();
   return send_stream;
 }
 
 void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(send_stream != nullptr);
 
   send_stream->Stop();
 
   webrtc::internal::AudioSendStream* audio_send_stream =
       static_cast<webrtc::internal::AudioSendStream*>(send_stream);
   uint32_t ssrc = audio_send_stream->config().rtp.ssrc;
   {
     WriteLockScoped write_lock(*send_crit_);
     size_t num_deleted = audio_send_ssrcs_.erase(ssrc);
     RTC_DCHECK_EQ(1, num_deleted);
   }
   {
     ReadLockScoped read_lock(*receive_crit_);
-    for (const auto& kv : audio_receive_ssrcs_) {
-      if (kv.second->config().rtp.local_ssrc == ssrc) {
-        kv.second->AssociateSendStream(nullptr);
+    for (AudioReceiveStream* stream : audio_receive_streams_) {
+      if (stream->config().rtp.local_ssrc == ssrc) {
+        stream->AssociateSendStream(nullptr);
       }
     }
   }
   UpdateAggregateNetworkState();
   delete audio_send_stream;
 }
 
 webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
     const webrtc::AudioReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   event_log_->LogAudioReceiveStreamConfig(config);
   AudioReceiveStream* receive_stream =
       new AudioReceiveStream(transport_send_->packet_router(), config,
                              config_.audio_state, event_log_);
   {
     WriteLockScoped write_lock(*receive_crit_);
-    RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
-               audio_receive_ssrcs_.end());
-    audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
+    audio_rtp_demuxer_.AddSink(config.rtp.remote_ssrc, receive_stream);
     receive_rtp_config_[config.rtp.remote_ssrc] =
         ReceiveRtpConfig(config.rtp.extensions, UseSendSideBwe(config));
+    audio_receive_streams_.insert(receive_stream);
 
     ConfigureSync(config.sync_group);
   }
   {
     ReadLockScoped read_lock(*send_crit_);
     auto it = audio_send_ssrcs_.find(config.rtp.local_ssrc);
     if (it != audio_send_ssrcs_.end()) {
       receive_stream->AssociateSendStream(it->second);
     }
   }
   receive_stream->SignalNetworkState(audio_network_state_);
   UpdateAggregateNetworkState();
   return receive_stream;
 }
 
 void Call::DestroyAudioReceiveStream(
     webrtc::AudioReceiveStream* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(receive_stream != nullptr);
   webrtc::internal::AudioReceiveStream* audio_receive_stream =
       static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
   {
     WriteLockScoped write_lock(*receive_crit_);
     const AudioReceiveStream::Config& config = audio_receive_stream->config();
     uint32_t ssrc = config.rtp.remote_ssrc;
     receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config))
         ->RemoveStream(ssrc);
-    size_t num_deleted = audio_receive_ssrcs_.erase(ssrc);
+    size_t num_deleted = audio_rtp_demuxer_.RemoveSink(audio_receive_stream);
     RTC_DCHECK(num_deleted == 1);
+    audio_receive_streams_.erase(audio_receive_stream);
     const std::string& sync_group = audio_receive_stream->config().sync_group;
     const auto it = sync_stream_mapping_.find(sync_group);
     if (it != sync_stream_mapping_.end() &&
         it->second == audio_receive_stream) {
       sync_stream_mapping_.erase(it);
       ConfigureSync(sync_group);
     }
     receive_rtp_config_.erase(ssrc);
   }
   UpdateAggregateNetworkState();
@@ skipping 76 matching lines @@
   VideoReceiveStream* receive_stream =
       new VideoReceiveStream(num_cpu_cores_, transport_send_->packet_router(),
                              std::move(configuration),
                              module_process_thread_.get(), call_stats_.get());
 
   const webrtc::VideoReceiveStream::Config& config = receive_stream->config();
   ReceiveRtpConfig receive_config(config.rtp.extensions,
                                   UseSendSideBwe(config));
   {
     WriteLockScoped write_lock(*receive_crit_);
-    RTC_DCHECK(video_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
-               video_receive_ssrcs_.end());
-    video_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
+    video_rtp_demuxer_.AddSink(config.rtp.remote_ssrc, receive_stream);
     if (config.rtp.rtx_ssrc) {
-      video_receive_ssrcs_[config.rtp.rtx_ssrc] = receive_stream;
+      video_rtp_demuxer_.AddSink(config.rtp.rtx_ssrc, receive_stream);
       // We record identical config for the rtx stream as for the main
       // stream. Since the transport_send_cc negotiation is per payload
       // type, we may get an incorrect value for the rtx stream, but
       // that is unlikely to matter in practice.
       receive_rtp_config_[config.rtp.rtx_ssrc] = receive_config;
     }
     receive_rtp_config_[config.rtp.remote_ssrc] = receive_config;
     video_receive_streams_.insert(receive_stream);
     ConfigureSync(config.sync_group);
   }
   receive_stream->SignalNetworkState(video_network_state_);
   UpdateAggregateNetworkState();
   event_log_->LogVideoReceiveStreamConfig(config);
   return receive_stream;
 }
 
 void Call::DestroyVideoReceiveStream(
     webrtc::VideoReceiveStream* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(receive_stream != nullptr);
-  VideoReceiveStream* receive_stream_impl = nullptr;
+  VideoReceiveStream* receive_stream_impl =
+      static_cast<VideoReceiveStream*>(receive_stream);
+  const VideoReceiveStream::Config& config = receive_stream_impl->config();
   {
     WriteLockScoped write_lock(*receive_crit_);
     // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a
     // separate SSRC there can be either one or two.
-    auto it = video_receive_ssrcs_.begin();
-    while (it != video_receive_ssrcs_.end()) {
-      if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) {
-        if (receive_stream_impl != nullptr)
-          RTC_DCHECK(receive_stream_impl == it->second);
-        receive_stream_impl = it->second;
-        receive_rtp_config_.erase(it->first);
-        it = video_receive_ssrcs_.erase(it);
-      } else {
-        ++it;
-      }
+    size_t num_deleted = video_rtp_demuxer_.RemoveSink(receive_stream_impl);
+    RTC_DCHECK_GE(num_deleted, 1);
+    receive_rtp_config_.erase(config.rtp.remote_ssrc);
+    if (config.rtp.rtx_ssrc) {
+      receive_rtp_config_.erase(config.rtp.rtx_ssrc);
     }
     video_receive_streams_.erase(receive_stream_impl);
-    RTC_CHECK(receive_stream_impl != nullptr);
-    ConfigureSync(receive_stream_impl->config().sync_group);
+    ConfigureSync(config.sync_group);
   }
-  const VideoReceiveStream::Config& config = receive_stream_impl->config();
 
   receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config))
       ->RemoveStream(config.rtp.remote_ssrc);
 
   UpdateAggregateNetworkState();
   delete receive_stream_impl;
 }
 
 FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
     const FlexfecReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   RecoveredPacketReceiver* recovered_packet_receiver = this;
   FlexfecReceiveStreamImpl* receive_stream = new FlexfecReceiveStreamImpl(
       config, recovered_packet_receiver, call_stats_->rtcp_rtt_stats(),
       module_process_thread_.get());
 
   {
     WriteLockScoped write_lock(*receive_crit_);
-
-    RTC_DCHECK(flexfec_receive_streams_.find(receive_stream) ==
-               flexfec_receive_streams_.end());
-    flexfec_receive_streams_.insert(receive_stream);
+    video_rtp_demuxer_.AddSink(config.remote_ssrc, receive_stream);
 
     for (auto ssrc : config.protected_media_ssrcs)
-      flexfec_receive_ssrcs_media_.insert(std::make_pair(ssrc, receive_stream));
-
-    RTC_DCHECK(flexfec_receive_ssrcs_protection_.find(config.remote_ssrc) ==
-               flexfec_receive_ssrcs_protection_.end());
-    flexfec_receive_ssrcs_protection_[config.remote_ssrc] = receive_stream;
+      video_rtp_demuxer_.AddSink(ssrc, receive_stream);
 
     RTC_DCHECK(receive_rtp_config_.find(config.remote_ssrc) ==
                receive_rtp_config_.end());
     receive_rtp_config_[config.remote_ssrc] =
         ReceiveRtpConfig(config.rtp_header_extensions, UseSendSideBwe(config));
   }
 
   // TODO(brandtr): Store config in RtcEventLog here.
 
   return receive_stream;
@@ skipping 11 matching lines @@
   {
     WriteLockScoped write_lock(*receive_crit_);
 
     const FlexfecReceiveStream::Config& config =
         receive_stream_impl->GetConfig();
     uint32_t ssrc = config.remote_ssrc;
     receive_rtp_config_.erase(ssrc);
 
     // Remove all SSRCs pointing to the FlexfecReceiveStreamImpl to be
     // destroyed.
-    auto prot_it = flexfec_receive_ssrcs_protection_.begin();
-    while (prot_it != flexfec_receive_ssrcs_protection_.end()) {
-      if (prot_it->second == receive_stream_impl)
-        prot_it = flexfec_receive_ssrcs_protection_.erase(prot_it);
-      else
-        ++prot_it;
-    }
-    auto media_it = flexfec_receive_ssrcs_media_.begin();
-    while (media_it != flexfec_receive_ssrcs_media_.end()) {
-      if (media_it->second == receive_stream_impl)
-        media_it = flexfec_receive_ssrcs_media_.erase(media_it);
-      else
-        ++media_it;
-    }
-
+    video_rtp_demuxer_.RemoveSink(receive_stream_impl);
     receive_side_cc_.GetRemoteBitrateEstimator(UseSendSideBwe(config))
         ->RemoveStream(ssrc);
-
-    flexfec_receive_streams_.erase(receive_stream_impl);
   }
 
   delete receive_stream_impl;
 }
 
 Call::Stats Call::GetStats() const {
   // TODO(solenberg): Some test cases in EndToEndTest use this from a different
   // thread. Re-enable once that is fixed.
   // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   Stats stats;
@@ skipping 66 matching lines @@
     ReadLockScoped read_lock(*send_crit_);
     for (auto& kv : audio_send_ssrcs_) {
       kv.second->SignalNetworkState(audio_network_state_);
     }
     for (auto& kv : video_send_ssrcs_) {
       kv.second->SignalNetworkState(video_network_state_);
     }
   }
   {
     ReadLockScoped read_lock(*receive_crit_);
-    for (auto& kv : audio_receive_ssrcs_) {
-      kv.second->SignalNetworkState(audio_network_state_);
+    for (AudioReceiveStream* audio_receive_stream : audio_receive_streams_) {
+      audio_receive_stream->SignalNetworkState(audio_network_state_);
     }
-    for (auto& kv : video_receive_ssrcs_) {
-      kv.second->SignalNetworkState(video_network_state_);
+    for (VideoReceiveStream* video_receive_stream : video_receive_streams_) {
+      video_receive_stream->SignalNetworkState(video_network_state_);
     }
   }
 }
 
 void Call::OnTransportOverheadChanged(MediaType media,
                                       int transport_overhead_per_packet) {
   switch (media) {
     case MediaType::AUDIO: {
       ReadLockScoped read_lock(*send_crit_);
       for (auto& kv : audio_send_ssrcs_) {
@@ skipping 61 matching lines @@
   bool have_video = false;
   {
     ReadLockScoped read_lock(*send_crit_);
     if (audio_send_ssrcs_.size() > 0)
       have_audio = true;
     if (video_send_ssrcs_.size() > 0)
       have_video = true;
   }
   {
     ReadLockScoped read_lock(*receive_crit_);
-    if (audio_receive_ssrcs_.size() > 0)
+    if (audio_receive_streams_.size() > 0)
       have_audio = true;
-    if (video_receive_ssrcs_.size() > 0)
+    if (video_receive_streams_.size() > 0)
       have_video = true;
   }
 
   NetworkState aggregate_state = kNetworkDown;
   if ((have_video && video_network_state_ == kNetworkUp) ||
       (have_audio && audio_network_state_ == kNetworkUp)) {
     aggregate_state = kNetworkUp;
   }
 
   LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
@@ skipping 70 matching lines @@
   if (sync_group.empty())
     return;
 
   AudioReceiveStream* sync_audio_stream = nullptr;
   // Find existing audio stream.
   const auto it = sync_stream_mapping_.find(sync_group);
   if (it != sync_stream_mapping_.end()) {
     sync_audio_stream = it->second;
   } else {
     // No configured audio stream, see if we can find one.
-    for (const auto& kv : audio_receive_ssrcs_) {
-      if (kv.second->config().sync_group == sync_group) {
+    for (AudioReceiveStream* stream : audio_receive_streams_) {
+      if (stream->config().sync_group == sync_group) {
         if (sync_audio_stream != nullptr) {
           LOG(LS_WARNING) << "Attempting to sync more than one audio stream "
                              "within the same sync group. This is not "
                              "supported in the current implementation.";
           break;
         }
-        sync_audio_stream = kv.second;
+        sync_audio_stream = stream;
       }
     }
   }
   if (sync_audio_stream)
     sync_stream_mapping_[sync_group] = sync_audio_stream;
   size_t num_synced_streams = 0;
   for (VideoReceiveStream* video_stream : video_receive_streams_) {
     if (video_stream->config().sync_group != sync_group)
       continue;
     ++num_synced_streams;
@@ skipping 29 matching lines @@
   bool rtcp_delivered = false;
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     ReadLockScoped read_lock(*receive_crit_);
     for (VideoReceiveStream* stream : video_receive_streams_) {
       if (stream->DeliverRtcp(packet, length))
         rtcp_delivered = true;
     }
   }
   if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
     ReadLockScoped read_lock(*receive_crit_);
-    for (auto& kv : audio_receive_ssrcs_) {
-      if (kv.second->DeliverRtcp(packet, length))
+    for (AudioReceiveStream* stream : audio_receive_streams_) {
+      if (stream->DeliverRtcp(packet, length))
         rtcp_delivered = true;
     }
   }
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     ReadLockScoped read_lock(*send_crit_);
     for (VideoSendStream* stream : video_send_streams_) {
       if (stream->DeliverRtcp(packet, length))
         rtcp_delivered = true;
     }
   }
@@ skipping 23 matching lines @@
   // TODO(nisse): We should parse the RTP header only here, and pass
   // on parsed_packet to the receive streams.
   rtc::Optional<RtpPacketReceived> parsed_packet =
       ParseRtpPacket(packet, length, &packet_time);
 
   if (!parsed_packet)
     return DELIVERY_PACKET_ERROR;
 
   NotifyBweOfReceivedPacket(*parsed_packet, media_type);
 
-  uint32_t ssrc = parsed_packet->Ssrc();
-
   if (media_type == MediaType::AUDIO) {
-    auto it = audio_receive_ssrcs_.find(ssrc);
-    if (it != audio_receive_ssrcs_.end()) {
+    if (audio_rtp_demuxer_.OnRtpPacket(*parsed_packet)) {
       received_bytes_per_second_counter_.Add(static_cast<int>(length));
       received_audio_bytes_per_second_counter_.Add(static_cast<int>(length));
-      it->second->OnRtpPacket(*parsed_packet);
       event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
       return DELIVERY_OK;
     }
-  }
-  if (media_type == MediaType::VIDEO) {
-    auto it = video_receive_ssrcs_.find(ssrc);
-    if (it != video_receive_ssrcs_.end()) {
+  } else if (media_type == MediaType::VIDEO) {
+    if (video_rtp_demuxer_.OnRtpPacket(*parsed_packet)) {
       received_bytes_per_second_counter_.Add(static_cast<int>(length));
       received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
-      it->second->OnRtpPacket(*parsed_packet);
-
-      // Deliver media packets to FlexFEC subsystem.
-      auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
-      for (auto it = it_bounds.first; it != it_bounds.second; ++it)
-        it->second->OnRtpPacket(*parsed_packet);
-
       event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
       return DELIVERY_OK;
     }
-  }
-  if (media_type == MediaType::VIDEO) {
-    received_bytes_per_second_counter_.Add(static_cast<int>(length));
-    // TODO(brandtr): Update here when FlexFEC supports protecting audio.
-    received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
-    auto it = flexfec_receive_ssrcs_protection_.find(ssrc);
-    if (it != flexfec_receive_ssrcs_protection_.end()) {
-      it->second->OnRtpPacket(*parsed_packet);
-      event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
-      return DELIVERY_OK;
-    }
   }
   return DELIVERY_UNKNOWN_SSRC;
 }
 
 PacketReceiver::DeliveryStatus Call::DeliverPacket(
     MediaType media_type,
     const uint8_t* packet,
     size_t length,
     const PacketTime& packet_time) {
   // TODO(solenberg): Tests call this function on a network thread, libjingle
@@ skipping 10 matching lines @@
 // audio packets with FlexFEC.
 void Call::OnRecoveredPacket(const uint8_t* packet, size_t length) {
   ReadLockScoped read_lock(*receive_crit_);
   rtc::Optional<RtpPacketReceived> parsed_packet =
       ParseRtpPacket(packet, length, nullptr);
   if (!parsed_packet)
     return;
 
   parsed_packet->set_recovered(true);
 
-  auto it = video_receive_ssrcs_.find(parsed_packet->Ssrc());
-  if (it == video_receive_ssrcs_.end())
-    return;
-
-  it->second->OnRtpPacket(*parsed_packet);
+  video_rtp_demuxer_.OnRtpPacket(*parsed_packet);
 }
 
 void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
                                      MediaType media_type) {
   auto it = receive_rtp_config_.find(packet.Ssrc());
   bool use_send_side_bwe =
       (it != receive_rtp_config_.end()) && it->second.use_send_side_bwe;
 
   RTPHeader header;
   packet.GetHeader(&header);
@@ skipping 13 matching lines @@
       (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
     receive_side_cc_.OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }
 }
 
 }  // namespace internal
 
 }  // namespace webrtc