Adding support for RTCRtpEncodingParameters.active flag.

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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 972 matching lines @@
   *codec = send_codec_->codec;
   return true;
 }
 
 bool WebRtcVideoChannel2::SetSend(bool send) {
   LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false");
   if (send && !send_codec_) {
     LOG(LS_ERROR) << "SetSend(true) called before setting codec.";
     return false;
   }
-  if (send) {
-    StartAllSendStreams();
-  } else {
-    StopAllSendStreams();
+  {
+    rtc::CritScope stream_lock(&stream_crit_);
+    for (const auto& kv : send_streams_) {
+      kv.second->SetSend(send);
+    }
   }
   sending_ = send;
   return true;
 }
 
 bool WebRtcVideoChannel2::SetVideoSend(uint32_t ssrc, bool enable,
                                        const VideoOptions* options) {
   TRACE_EVENT0("webrtc", "SetVideoSend");
   LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
                << "options: " << (options ? options->ToString() : "nullptr")
@@ skipping 62 matching lines @@
     rtcp_receiver_report_ssrc_ = ssrc;
     LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
                     "a send stream.";
     for (auto& kv : receive_streams_)
       kv.second->SetLocalSsrc(ssrc);
   }
   if (default_send_ssrc_ == 0) {
     default_send_ssrc_ = ssrc;
   }
   if (sending_) {
-    stream->Start();
+    stream->SetSend(true);
   }
 
   return true;
 }
 
 bool WebRtcVideoChannel2::RemoveSendStream(uint32_t ssrc) {
   LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
 
   if (ssrc == 0) {
     if (default_send_ssrc_ == 0) {
@@ skipping 385 matching lines @@
   rtc::PacketOptions rtc_options;
   rtc_options.packet_id = options.packet_id;
   return MediaChannel::SendPacket(&packet, rtc_options);
 }
 
 bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
   rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
   return MediaChannel::SendRtcp(&packet, rtc::PacketOptions());
 }
 
-void WebRtcVideoChannel2::StartAllSendStreams() {
-  rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
-           send_streams_.begin();
-       it != send_streams_.end(); ++it) {
-    it->second->Start();
-  }
-}
-
-void WebRtcVideoChannel2::StopAllSendStreams() {
-  rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
-           send_streams_.begin();
-       it != send_streams_.end(); ++it) {
-    it->second->Stop();
-  }
-}
-
 WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
     VideoSendStreamParameters(
         const webrtc::VideoSendStream::Config& config,
         const VideoOptions& options,
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings)
     : config(config),
       options(options),
       max_bitrate_bps(max_bitrate_bps),
       codec_settings(codec_settings) {}
@@ skipping 362 matching lines @@
   if (!ValidateRtpParameters(new_parameters)) {
     return false;
   }
 
   rtc::CritScope cs(&lock_);
   if (new_parameters.encodings[0].max_bitrate_bps !=
       rtp_parameters_.encodings[0].max_bitrate_bps) {
     pending_encoder_reconfiguration_ = true;
   }
   rtp_parameters_ = new_parameters;
+  // Encoding may have been activated/deactivated.
+  UpdateSendState();
   return true;
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::ValidateRtpParameters(
     const webrtc::RtpParameters& rtp_parameters) {
   if (rtp_parameters.encodings.size() != 1) {
     LOG(LS_ERROR)
         << "Attempted to set RtpParameters without exactly one encoding";
     return false;
   }
@@ skipping 92 matching lines @@
       codec_settings.codec);
 
   stream_->ReconfigureVideoEncoder(encoder_config);
 
   encoder_config.encoder_specific_settings = NULL;
   pending_encoder_reconfiguration_ = false;
 
   parameters_.encoder_config = encoder_config;
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
+void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSend(bool send) {
   rtc::CritScope cs(&lock_);
-  RTC_DCHECK(stream_ != NULL);
-  stream_->Start();
-  sending_ = true;
+  RTC_DCHECK(stream_ != nullptr);
+  sending_ = send;
+  UpdateSendState();
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
+void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateSendState() {
   rtc::CritScope cs(&lock_);

[pbos-webrtc, 2016/03/22 18:13:43]

Don't take the lock here. (see header comment)

Also put a TODO on that encodings[>0].active should be handled in the future.

[Taylor Brandstetter, 2016/03/22 18:32:43]

Done.

-  if (stream_ != NULL) {
-    stream_->Stop();
+  if (sending_ && rtp_parameters_.encodings[0].active) {
+    RTC_DCHECK(stream_ != nullptr);
+    stream_->Start();
+  } else {
+    if (stream_ != nullptr) {
+      stream_->Stop();
+    }
   }
-  sending_ = false;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate(Load load) {
   if (worker_thread_ != rtc::Thread::Current()) {
     invoker_.AsyncInvoke<void>(
         worker_thread_,
         rtc::Bind(&WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate,
                   this, load));
     return;
   }
@@ skipping 593 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket