Combining SetVideoSend and SetSource into one method.

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 980 matching lines @@
   {
     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) {
+bool WebRtcVideoChannel2::SetVideoSend(uint32_t ssrc,
+                                       bool enable,
+                                       const VideoOptions* options,
+                                       VideoCapturer* capturer) {
   TRACE_EVENT0("webrtc", "SetVideoSend");
+  RTC_DCHECK(ssrc != 0);
   LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
                << "options: " << (options ? options->ToString() : "nullptr")
-               << ").";
+               << ", capturer = "
+               << (capturer != nullptr ? "(capturer)" : "NULL") << ")";
 
   // TODO(solenberg): The state change should be fully rolled back if any one of
   //                  these calls fail.
-  if (!MuteStream(ssrc, !enable)) {
+  rtc::CritScope stream_lock(&stream_crit_);
+  const auto& kv = send_streams_.find(ssrc);
+  if (kv == send_streams_.end()) {
+    LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
     return false;
   }
-  if (enable && options) {
-    SetOptions(ssrc, *options);
-  }
+
+  kv->second->SetVideoSend(enable, options, capturer);
   return true;
 }
 
 bool WebRtcVideoChannel2::ValidateSendSsrcAvailability(
     const StreamParams& sp) const {
   for (uint32_t ssrc : sp.ssrcs) {
     if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) {
       LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists.";
       return false;
     }
@@ skipping 279 matching lines @@
   // Get send stream bitrate stats.
   rtc::CritScope stream_lock(&stream_crit_);
   for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
            send_streams_.begin();
        stream != send_streams_.end(); ++stream) {
     stream->second->FillBandwidthEstimationInfo(&bwe_info);
   }
   video_media_info->bw_estimations.push_back(bwe_info);
 }
 
-bool WebRtcVideoChannel2::SetCapturer(uint32_t ssrc, VideoCapturer* capturer) {
-  LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
-               << (capturer != NULL ? "(capturer)" : "NULL");
-  RTC_DCHECK(ssrc != 0);
-  {
-    rtc::CritScope stream_lock(&stream_crit_);
-    const auto& kv = send_streams_.find(ssrc);
-    if (kv == send_streams_.end()) {
-      LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
-      return false;
-    }
-    if (!kv->second->SetCapturer(capturer)) {
-      return false;
-    }
-  }
-  return true;
-}
-
 void WebRtcVideoChannel2::OnPacketReceived(
     rtc::CopyOnWriteBuffer* packet,
     const rtc::PacketTime& packet_time) {
   const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
                                               packet_time.not_before);
   const webrtc::PacketReceiver::DeliveryStatus delivery_result =
       call_->Receiver()->DeliverPacket(
           webrtc::MediaType::VIDEO,
           packet->cdata(), packet->size(),
           webrtc_packet_time);
@@ skipping 60 matching lines @@
       webrtc_packet_time);
 }
 
 void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
   LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
   call_->SignalChannelNetworkState(
       webrtc::MediaType::VIDEO,
       ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
 }
 
-bool WebRtcVideoChannel2::MuteStream(uint32_t ssrc, bool mute) {
-  LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
-                  << (mute ? "mute" : "unmute");
-  RTC_DCHECK(ssrc != 0);
-  rtc::CritScope stream_lock(&stream_crit_);
-  const auto& kv = send_streams_.find(ssrc);
-  if (kv == send_streams_.end()) {
-    LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
-    return false;
-  }
-
-  kv->second->MuteStream(mute);
-  return true;
-}
-
-// TODO(pbos): Remove SetOptions in favor of SetSendParameters.
-void WebRtcVideoChannel2::SetOptions(uint32_t ssrc,
-                                     const VideoOptions& options) {
-  LOG(LS_INFO) << "SetOptions: ssrc " << ssrc << ": " << options.ToString();
-
-  rtc::CritScope stream_lock(&stream_crit_);
-  const auto& kv = send_streams_.find(ssrc);
-  if (kv == send_streams_.end()) {
-    return;
-  }
-  kv->second->SetOptions(options);
-}
-
 void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
   MediaChannel::SetInterface(iface);
   // Set the RTP recv/send buffer to a bigger size
   MediaChannel::SetOption(NetworkInterface::ST_RTP,
                           rtc::Socket::OPT_RCVBUF,
                           kVideoRtpBufferSize);
 
   // Speculative change to increase the outbound socket buffer size.
   // In b/15152257, we are seeing a significant number of packets discarded
   // due to lack of socket buffer space, although it's not yet clear what the
@@ skipping 152 matching lines @@
   // Not sending, abort after reconfiguration. Reconfiguration should still
   // occur to permit sending this input as quickly as possible once we start
   // sending (without having to reconfigure then).
   if (!sending_) {
     return;
   }
 
   stream_->Input()->IncomingCapturedFrame(video_frame);
 }
 
-bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
+bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
+    bool enable,
+    const VideoOptions* options,
     VideoCapturer* capturer) {
-  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
+  TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!DisconnectCapturer() && capturer == NULL) {
-    return false;
+
+  bool capturer_changing = capturer_ != capturer;
+  if (capturer_changing) {
+    if (!DisconnectCapturer() && capturer == nullptr) {
+      return false;
+    }
   }
 
   {
     rtc::CritScope cs(&lock_);
 
-    // Reset timestamps to realign new incoming frames to a webrtc timestamp. A
-    // new capturer may have a different timestamp delta than the previous one.
-    first_frame_timestamp_ms_ = 0;
+    muted_ = !enable;
+    if (enable && options) {
+      VideoOptions old_options = parameters_.options;
+      parameters_.options.SetAll(*options);
+      if (parameters_.options != old_options) {
+        // Reconfigure encoder settings on the next frame or stream recreation.
+        pending_encoder_reconfiguration_ = true;
+      }
+    }
 
-    if (capturer == NULL) {
-      if (stream_ != NULL) {
+    if (capturer_changing) {
+      // Reset timestamps to realign new incoming frames to a webrtc timestamp.
+      // A new capturer may have a different timestamp delta than the previous
+      // one.
+      first_frame_timestamp_ms_ = 0;
+
+      if (capturer == nullptr && stream_ != nullptr) {
         LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
         webrtc::VideoFrame black_frame;
 
         CreateBlackFrame(&black_frame, last_dimensions_.width,
                          last_dimensions_.height, last_rotation_);
 
         // Force this black frame not to be dropped due to timestamp order
         // check. As IncomingCapturedFrame will drop the frame if this frame's
         // timestamp is less than or equal to last frame's timestamp, it is
         // necessary to give this black frame a larger timestamp than the
         // previous one.
         last_frame_timestamp_ms_ += 1;
         black_frame.set_render_time_ms(last_frame_timestamp_ms_);
         stream_->Input()->IncomingCapturedFrame(black_frame);
       }
-
-      capturer_ = NULL;
-      return true;

[Taylor Brandstetter, 2016/03/29 22:30:35]

I got rid of this early return and added "if (capturer_changing && capturer_ !=
nullptr)" below because I thought that makes the method's flow more clear.

+      capturer_ = capturer;
     }
   }
-  capturer_ = capturer;
+
   // |capturer_->AddOrUpdateSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
-  capturer_->AddOrUpdateSink(this, sink_wants_);
+  if (capturer_changing && capturer_ != nullptr) {
+    capturer_->AddOrUpdateSink(this, sink_wants_);
+  }
   return true;
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
-  rtc::CritScope cs(&lock_);
-  muted_ = mute;
-}
-
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (capturer_ == NULL) {
     return false;
   }
 
   // |capturer_->RemoveSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   capturer_->RemoveSink(this);
   capturer_ = NULL;
   // Reset |cpu_restricted_counter_| if the capturer is changed. It is not
   // possible to know if the video resolution is restricted by CPU usage after
   // the capturer is changed since the next capturer might be screen capture
   // with another resolution and frame rate.
   cpu_restricted_counter_ = 0;
   return true;
 }
 
 const std::vector<uint32_t>&
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
   return ssrcs_;
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
-    const VideoOptions& options) {
-  rtc::CritScope cs(&lock_);
-
-  parameters_.options.SetAll(options);
-  // Reconfigure encoder settings on the next frame or stream
-  // recreation.
-  pending_encoder_reconfiguration_ = true;
-}
-
 webrtc::VideoCodecType CodecTypeFromName(const std::string& name) {
   if (CodecNamesEq(name, kVp8CodecName)) {
     return webrtc::kVideoCodecVP8;
   } else if (CodecNamesEq(name, kVp9CodecName)) {
     return webrtc::kVideoCodecVP9;
   } else if (CodecNamesEq(name, kH264CodecName)) {
     return webrtc::kVideoCodecH264;
   }
   return webrtc::kVideoCodecUnknown;
 }
@@ skipping 881 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