Move RTP module activation into PayloadRouter.

webrtc/video/vie_channel.cc

 /*
  *  Copyright (c) 2012 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 130 matching lines @@
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     module_process_thread_->RegisterModule(rtp_rtcp);
 
   rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
   if (paced_sender_) {
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
       rtp_rtcp->SetStorePacketsStatus(true, kMinSendSidePacketHistorySize);
   }
   packet_router_->AddRtpModule(rtp_rtcp_modules_[0], sender_);
   if (sender_) {
-    send_payload_router_->SetSendingRtpModules(
-        std::vector<RtpRtcp*>(1, rtp_rtcp_modules_[0]));
+    send_payload_router_->SetSendingRtpModules(1);
     RTC_DCHECK(!send_payload_router_->active());
   } else {
     if (vcm_->RegisterReceiveCallback(this) != 0) {
       return -1;
     }
     vcm_->RegisterFrameTypeCallback(this);
     vcm_->RegisterReceiveStatisticsCallback(this);
     vcm_->RegisterDecoderTimingCallback(this);
     vcm_->SetRenderDelay(kDefaultRenderDelayMs);
   }
   return 0;
 }
 
 ViEChannel::~ViEChannel() {
   UpdateHistograms();
   // Make sure we don't get more callbacks from the RTP module.
   module_process_thread_->DeRegisterModule(
       vie_receiver_.GetReceiveStatistics());
   if (sender_) {
-    send_payload_router_->SetSendingRtpModules(std::vector<RtpRtcp*>());
+    send_payload_router_->SetSendingRtpModules(0);
   }
   for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i)
     packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     module_process_thread_->DeRegisterModule(rtp_rtcp);
     delete rtp_rtcp;
   }
 }
 
 void ViEChannel::UpdateHistograms() {
@@ skipping 91 matching lines @@
     LOG_F(LS_ERROR) << "Incorrect config "
                     << video_codec.numberOfSimulcastStreams;
     return -1;
   }
   // Update the RTP module with the settings.
   // Stop and Start the RTP module -> trigger new SSRC, if an SSRC hasn't been
   // set explicitly.
   // The first layer is always active, so the first module can be checked for
   // sending status.
   bool is_sending = rtp_rtcp_modules_[0]->Sending();
-  bool router_was_active = send_payload_router_->active();
   send_payload_router_->set_active(false);
-  send_payload_router_->SetSendingRtpModules(std::vector<RtpRtcp*>());
+  send_payload_router_->SetSendingRtpModules(0);
 
   std::vector<RtpRtcp*> registered_modules;
-  std::vector<RtpRtcp*> deregistered_modules;
   size_t num_active_modules = video_codec.numberOfSimulcastStreams > 0
                                    ? video_codec.numberOfSimulcastStreams
                                    : 1;
   size_t num_prev_active_modules;
   {
     // Cache which modules are active so StartSend can know which ones to start.
     rtc::CritScope lock(&crit_);
     num_prev_active_modules = num_active_rtp_rtcp_modules_;
     num_active_rtp_rtcp_modules_ = num_active_modules;
   }
   for (size_t i = 0; i < num_active_modules; ++i)
     registered_modules.push_back(rtp_rtcp_modules_[i]);
 
-  for (size_t i = num_active_modules; i < rtp_rtcp_modules_.size(); ++i)
-    deregistered_modules.push_back(rtp_rtcp_modules_[i]);
-
-  // Disable inactive modules.
-  for (RtpRtcp* rtp_rtcp : deregistered_modules) {
-    rtp_rtcp->SetSendingStatus(false);
-    rtp_rtcp->SetSendingMediaStatus(false);
-  }
-
-  // Configure active modules.
-  for (RtpRtcp* rtp_rtcp : registered_modules) {
-    rtp_rtcp->DeRegisterSendPayload(video_codec.plType);
-    if (rtp_rtcp->RegisterSendPayload(video_codec) != 0) {
-      return -1;
-    }
-    rtp_rtcp->SetSendingStatus(is_sending);
-    rtp_rtcp->SetSendingMediaStatus(is_sending);
-  }
-
   // |RegisterSimulcastRtpRtcpModules| resets all old weak pointers and old
   // modules can be deleted after this step.
   vie_receiver_.RegisterRtpRtcpModules(registered_modules);
 
   // Update the packet and payload routers with the sending RtpRtcp modules.
-  send_payload_router_->SetSendingRtpModules(registered_modules);
+  send_payload_router_->SetSendingRtpModules(num_active_modules);
 
-  if (router_was_active)
-    send_payload_router_->set_active(true);
+  send_payload_router_->set_active(is_sending);
 
   // Deregister previously registered modules.
   for (size_t i = num_active_modules; i < num_prev_active_modules; ++i)
     packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], true);
   // Register new active modules.
   for (size_t i = num_prev_active_modules; i < num_active_modules; ++i)
     packet_router_->AddRtpModule(rtp_rtcp_modules_[i], true);
   return 0;
 }
 
@@ skipping 194 matching lines @@
     SendSideDelayObserver* observer) {
   send_side_delay_observer_.Set(observer);
 }
 
 void ViEChannel::RegisterSendBitrateObserver(
     BitrateStatisticsObserver* observer) {
   send_bitrate_observer_.Set(observer);
 }
 
 int32_t ViEChannel::StartSend() {
-  rtc::CritScope lock(&crit_);
-
   if (rtp_rtcp_modules_[0]->Sending())
     return -1;
 
-  for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) {
-    RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[i];
-    // Only have senders send media.
-    rtp_rtcp->SetSendingMediaStatus(sender_);
-    rtp_rtcp->SetSendingStatus(true);
+  if (!sender_) {
+    rtp_rtcp_modules_[0]->SetSendingStatus(true);

[stefan-webrtc, 2016/02/26 14:49:07]

Shouldn't we rely on the payload router to do this?

[pbos-webrtc, 2016/02/26 14:58:56]

Not on the receiver side. I'm removing this in a later CL though.

+  } else {
+    send_payload_router_->set_active(true);
   }
-  if (sender_)
-    send_payload_router_->set_active(true);
   return 0;
 }
 
 int32_t ViEChannel::StopSend() {
-  if (sender_)
+  if (!rtp_rtcp_modules_[0]->Sending())
+    return -1;
+
+  if (!sender_) {
+    rtp_rtcp_modules_[0]->SetSendingStatus(false);
+  } else {
     send_payload_router_->set_active(false);
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->SetSendingMediaStatus(false);
-
-  if (!rtp_rtcp_modules_[0]->Sending()) {
-    return -1;
   }
 
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
-    rtp_rtcp->SetSendingStatus(false);
-  }
   return 0;
 }
 
 const std::vector<RtpRtcp*>& ViEChannel::rtp_rtcp() const {
   return rtp_rtcp_modules_;
 }
 
 ViEReceiver* ViEChannel::vie_receiver() {
   return &vie_receiver_;
 }
@@ skipping 204 matching lines @@
   rtc::CritScope lock(&crit_);
   receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   rtc::CritScope lock(&crit_);
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc