Adding reduced size RTCP configuration down to the video stream level.

talk/media/webrtc/webrtcvideoengine2.cc

Index: talk/media/webrtc/webrtcvideoengine2.cc
diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc
index 7d1ddbadff11590e1c2b0cda96ee7d91cc0cb736..89b9c2c88abec3e842c9edc98832c655dce36ca9 100644
--- a/talk/media/webrtc/webrtcvideoengine2.cc
+++ b/talk/media/webrtc/webrtcvideoengine2.cc
@@ -856,20 +856,42 @@ bool WebRtcVideoChannel2::ReceiveCodecsHaveChanged(
   return false;
 }
 
-bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
+bool WebRtcVideoChannel2::SetSendParameters(
+    const VideoSendParameters& send_params) {
   // TODO(pbos): Refactor this to only recreate the send streams once
   // instead of 4 times.
-  return (SetSendCodecs(params.codecs) &&
-          SetSendRtpHeaderExtensions(params.extensions) &&
-          SetMaxSendBandwidth(params.max_bandwidth_bps) &&
-          SetOptions(params.options));
+  if (!SetSendCodecs(send_params.codecs) ||
+      !SetSendRtpHeaderExtensions(send_params.extensions) ||
+      !SetMaxSendBandwidth(send_params.max_bandwidth_bps) ||
+      !SetOptions(send_params.options)) {
+    return false;
+  }
+  if (send_params_.rtcp.reduced_size != send_params.rtcp.reduced_size) {
+    rtc::CritScope stream_lock(&stream_crit_);
+    for (auto& kv : send_streams_) {
+      kv.second->SetSendParameters(send_params);

[Taylor Brandstetter, 2015/10/23 17:16:32]

Here, I could have made a new method, "SetSendReducedSizeRtcp". But that felt
counterproductive since we plan (I assume) to eventually have just one
"SetSendParameters".

[pthatcher1, 2015/11/23 21:59:06]

Yeah, we want everything to go in SetSendParameters.

+    }
+  }
+  send_params_ = send_params;
+  return true;
 }
 
-bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) {
+bool WebRtcVideoChannel2::SetRecvParameters(
+    const VideoRecvParameters& recv_params) {
   // TODO(pbos): Refactor this to only recreate the recv streams once
   // instead of twice.
-  return (SetRecvCodecs(params.codecs) &&
-          SetRecvRtpHeaderExtensions(params.extensions));
+  if (!SetRecvCodecs(recv_params.codecs) ||
+      !SetRecvRtpHeaderExtensions(recv_params.extensions)) {
+    return false;
+  }
+  if (recv_params_.rtcp.reduced_size != recv_params.rtcp.reduced_size) {
+    rtc::CritScope stream_lock(&stream_crit_);
+    for (auto& kv : receive_streams_) {
+      kv.second->SetRecvParameters(recv_params);
+    }
+  }
+  recv_params_ = recv_params;
+  return true;
 }
 
 std::string WebRtcVideoChannel2::CodecSettingsVectorToString(
@@ -1088,15 +1110,10 @@ bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
   webrtc::VideoSendStream::Config config(this);
   config.overuse_callback = this;
 
-  WebRtcVideoSendStream* stream =
-      new WebRtcVideoSendStream(call_,
-                                sp,
-                                config,
-                                external_encoder_factory_,
-                                options_,
-                                bitrate_config_.max_bitrate_bps,
-                                send_codec_,
-                                send_rtp_extensions_);
+  WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
+      call_, sp, config, external_encoder_factory_, options_,
+      bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
+      send_params_);
 
   uint32_t ssrc = sp.first_ssrc();
   RTC_DCHECK(ssrc != 0);
@@ -1240,6 +1257,9 @@ void WebRtcVideoChannel2::ConfigureReceiverRtp(
   config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
 
   config->rtp.extensions = recv_rtp_extensions_;
+  config->rtp.rtcp_mode = recv_params_.rtcp.reduced_size
+                              ? webrtc::RtcpMode::kReducedSize
+                              : webrtc::RtcpMode::kCompound;
 
   // TODO(pbos): This protection is against setting the same local ssrc as
   // remote which is not permitted by the lower-level API. RTCP requires a
@@ -1731,7 +1751,10 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
     const VideoOptions& options,
     int max_bitrate_bps,
     const Settable<VideoCodecSettings>& codec_settings,
-    const std::vector<webrtc::RtpExtension>& rtp_extensions)
+    const std::vector<webrtc::RtpExtension>& rtp_extensions,
+    // TODO(pbos): Don't duplicate information between send_params,
+    // rtp_extensions, options, etc.
+    const VideoSendParameters& send_params)
     : ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
@@ -1752,6 +1775,9 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
                  &parameters_.config.rtp.rtx.ssrcs);
   parameters_.config.rtp.c_name = sp.cname;
   parameters_.config.rtp.extensions = rtp_extensions;
+  parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
+                                         ? webrtc::RtcpMode::kReducedSize
+                                         : webrtc::RtcpMode::kCompound;
 
   VideoCodecSettings params;
   if (codec_settings.Get(&params)) {
@@ -2068,6 +2094,18 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions(
   }
 }
 
+void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters(
+    const VideoSendParameters& send_params) {
+  rtc::CritScope cs(&lock_);

[pthatcher1, 2015/10/23 20:40:01]

Should we do another check to see if it's changed before calling
RecreateWebRtcStream? 

[Taylor Brandstetter, 2015/11/11 19:42:40]

For the other methods, only WebRtcVideoChannel2 checks if things changed, not
WebRtcVideoSendStream. So I just kept it this way for consistency.

+  parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size
+                                         ? webrtc::RtcpMode::kReducedSize
+                                         : webrtc::RtcpMode::kCompound;
+  if (stream_ != nullptr) {
+    LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
+    RecreateWebRtcStream();
+  }
+}
+
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const Dimensions& dimensions,
@@ -2499,6 +2537,15 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
   RecreateWebRtcStream();
 }
 
+void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvParameters(
+    const VideoRecvParameters& recv_params) {
+  config_.rtp.rtcp_mode = recv_params.rtcp.reduced_size
+                              ? webrtc::RtcpMode::kReducedSize
+                              : webrtc::RtcpMode::kCompound;
+  LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvParameters";
+  RecreateWebRtcStream();
+}
+
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
   if (stream_ != NULL) {
     call_->DestroyVideoReceiveStream(stream_);