Consolidate setters into SetRecvParameters.

talk/media/webrtc/webrtcvideoengine2.cc

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 637 matching lines @@
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   SetDefaultOptions();
   options_.SetAll(options);
   if (options_.cpu_overuse_detection)
     signal_cpu_adaptation_ = *options_.cpu_overuse_detection;
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   default_send_ssrc_ = 0;
-  SetRecvCodecs(recv_codecs);
+  RTC_DCHECK(ValidateCodecFormats(recv_codecs));
+  recv_codecs_ = FilterSupportedCodecs(MapCodecs(recv_codecs));
 }
 
 void WebRtcVideoChannel2::SetDefaultOptions() {
   options_.cpu_overuse_detection = rtc::Optional<bool>(true);
   options_.dscp = rtc::Optional<bool>(false);
   options_.suspend_below_min_bitrate = rtc::Optional<bool>(false);
   options_.screencast_min_bitrate = rtc::Optional<int>(0);
 }
 
 WebRtcVideoChannel2::~WebRtcVideoChannel2() {
@@ skipping 68 matching lines @@
 }
 
 bool WebRtcVideoChannel2::GetChangedSendParameters(
     const VideoSendParameters& params,
     ChangedSendParameters* changed_params) const {
   if (!ValidateCodecFormats(params.codecs) ||
       !ValidateRtpExtensions(params.extensions)) {
     return false;
   }
 
-  // ==== SEND CODEC ====
+  // Handle send codec.
   const std::vector<VideoCodecSettings> supported_codecs =
       FilterSupportedCodecs(MapCodecs(params.codecs));
 
   if (supported_codecs.empty()) {
     LOG(LS_ERROR) << "No video codecs supported.";
     return false;
   }
 
   if (!send_codec_ || supported_codecs.front() != *send_codec_) {
-    // Send codec has changed.
     changed_params->codec =
         rtc::Optional<VideoCodecSettings>(supported_codecs.front());
   }
 
-  // ==== RTP HEADER EXTENSIONS ====
+  // Handle RTP header extensions.
   std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
       params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true);
   if (send_rtp_extensions_ != filtered_extensions) {
     changed_params->rtp_header_extensions =
         rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
   }
 
-  // ==== MAX BITRATE ====
+  // Handle max bitrate.
   if (params.max_bandwidth_bps != bitrate_config_.max_bitrate_bps &&
       params.max_bandwidth_bps >= 0) {
     // 0 uncaps max bitrate (-1).
     changed_params->max_bandwidth_bps = rtc::Optional<int>(
         params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps);
   }
 
-  // ==== OPTIONS ====
+  // Handle options.
   // TODO(pbos): Require VideoSendParameters to contain a full set of options
   // and check if params.options != options_ instead of applying a delta.
   VideoOptions new_options = options_;
   new_options.SetAll(params.options);
   if (!(new_options == options_)) {
     changed_params->options = rtc::Optional<VideoOptions>(new_options);
   }
 
+  // Handle RTCP mode.
   if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
     changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>(
         params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
                                  : webrtc::RtcpMode::kCompound);
   }
 
   return true;
 }
 
 bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
@@ skipping 68 matching lines @@
         kv.second->SetFeedbackParameters(HasNack(send_codec_->codec),
                                          HasRemb(send_codec_->codec),
                                          HasTransportCc(send_codec_->codec));
       }
     }
   }
   send_params_ = params;
   return true;
 }
 
+bool WebRtcVideoChannel2::GetChangedRecvParameters(
+    const VideoRecvParameters& params,
+    ChangedRecvParameters* changed_params) const {
+  if (!ValidateCodecFormats(params.codecs) ||
+      !ValidateRtpExtensions(params.extensions)) {
+    return false;
+  }
+
+  // Handle receive codecs.
+  const std::vector<VideoCodecSettings> mapped_codecs =
+      MapCodecs(params.codecs);
+  if (mapped_codecs.empty()) {
+    LOG(LS_ERROR) << "SetRecvParameters called without any video codecs.";
+    return false;
+  }
+
+  std::vector<VideoCodecSettings> supported_codecs =
+      FilterSupportedCodecs(mapped_codecs);
+
+  if (mapped_codecs.size() != supported_codecs.size()) {
+    LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codecs.";
+    return false;
+  }
+
+  if (ReceiveCodecsHaveChanged(recv_codecs_, supported_codecs)) {
+    changed_params->codec_settings =
+        rtc::Optional<std::vector<VideoCodecSettings>>(supported_codecs);
+  }
+
+  // Handle RTP header extensions.
+  std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
+      params.extensions, webrtc::RtpExtension::IsSupportedForVideo, false);
+  if (filtered_extensions != recv_rtp_extensions_) {
+    changed_params->rtp_header_extensions =
+        rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions);
+  }
+
+  // Handle RTCP mode.
+  if (params.rtcp.reduced_size != recv_params_.rtcp.reduced_size) {
+    changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>(
+        params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
+                                 : webrtc::RtcpMode::kCompound);
+  }
+
+  return true;
+}
+
 bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvParameters");
   LOG(LS_INFO) << "SetRecvParameters: " << params.ToString();
-  // TODO(pbos): Refactor this to only recreate the recv streams once
-  // instead of twice.
-  if (!SetRecvCodecs(params.codecs) ||
-      !SetRecvRtpHeaderExtensions(params.extensions)) {
+  ChangedRecvParameters changed_params;
+  if (!GetChangedRecvParameters(params, &changed_params)) {
     return false;
   }
-  if (recv_params_.rtcp.reduced_size != params.rtcp.reduced_size) {
+  if (changed_params.rtp_header_extensions) {
+    recv_rtp_extensions_ = *changed_params.rtp_header_extensions;
+  }
+  if (changed_params.codec_settings) {
+    LOG(LS_INFO) << "Changing recv codecs from "
+                 << CodecSettingsVectorToString(recv_codecs_) << " to "
+                 << CodecSettingsVectorToString(*changed_params.codec_settings);
+    recv_codecs_ = *changed_params.codec_settings;
+  }
+
+  {
     rtc::CritScope stream_lock(&stream_crit_);
     for (auto& kv : receive_streams_) {
-      kv.second->SetRecvParameters(params);
+      kv.second->SetRecvParameters(changed_params);
     }
   }
   recv_params_ = params;
   return true;
 }
 
 std::string WebRtcVideoChannel2::CodecSettingsVectorToString(
     const std::vector<VideoCodecSettings>& codecs) {
   std::stringstream out;
   out << '{';
   for (size_t i = 0; i < codecs.size(); ++i) {
     out << codecs[i].codec.ToString();
     if (i != codecs.size() - 1) {
       out << ", ";
     }
   }
   out << '}';
   return out.str();
 }
 
-bool WebRtcVideoChannel2::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
-  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvCodecs");
-  LOG(LS_INFO) << "SetRecvCodecs: " << CodecVectorToString(codecs);
-  if (!ValidateCodecFormats(codecs)) {
-    return false;
-  }
-
-  const std::vector<VideoCodecSettings> mapped_codecs = MapCodecs(codecs);
-  if (mapped_codecs.empty()) {
-    LOG(LS_ERROR) << "SetRecvCodecs called without any video codecs.";
-    return false;
-  }
-
-  std::vector<VideoCodecSettings> supported_codecs =
-      FilterSupportedCodecs(mapped_codecs);
-
-  if (mapped_codecs.size() != supported_codecs.size()) {
-    LOG(LS_ERROR) << "SetRecvCodecs called with unsupported video codecs.";
-    return false;
-  }
-
-  // Prevent reconfiguration when setting identical receive codecs.
-  if (!ReceiveCodecsHaveChanged(recv_codecs_, supported_codecs)) {
-    LOG(LS_INFO)
-        << "Ignoring call to SetRecvCodecs because codecs haven't changed.";
-    return true;
-  }
-
-  LOG(LS_INFO) << "Changing recv codecs from "
-               << CodecSettingsVectorToString(recv_codecs_) << " to "
-               << CodecSettingsVectorToString(supported_codecs);
-  recv_codecs_ = supported_codecs;
-
-  rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
-           receive_streams_.begin();
-       it != receive_streams_.end(); ++it) {
-    it->second->SetRecvCodecs(recv_codecs_);
-  }
-
-  return true;
-}
-
 bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
   if (!send_codec_) {
     LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
     return false;
   }
   *codec = send_codec_->codec;
   return true;
 }
 
 bool WebRtcVideoChannel2::SetSendStreamFormat(uint32_t ssrc,
@@ skipping 470 matching lines @@
   rtc::CritScope stream_lock(&stream_crit_);
   if (send_streams_.find(ssrc) == send_streams_.end()) {
     LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
     return false;
   }
 
   send_streams_[ssrc]->MuteStream(mute);
   return true;
 }
 
-bool WebRtcVideoChannel2::SetRecvRtpHeaderExtensions(
-    const std::vector<RtpHeaderExtension>& extensions) {
-  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvRtpHeaderExtensions");
-  if (!ValidateRtpExtensions(extensions)) {
-    return false;
-  }
-  std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions(
-      extensions, webrtc::RtpExtension::IsSupportedForVideo, false);
-  if (recv_rtp_extensions_ == filtered_extensions) {
-    LOG(LS_INFO) << "Ignoring call to SetRecvRtpHeaderExtensions because "
-                    "header extensions haven't changed.";
-    return true;
-  }
-  recv_rtp_extensions_.swap(filtered_extensions);
-
-  rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
-           receive_streams_.begin();
-       it != receive_streams_.end(); ++it) {
-    it->second->SetRtpExtensions(recv_rtp_extensions_);
-  }
-  return true;
-}
-
 // TODO(pbos): Remove SetOptions in favor of SetSendParameters.
 void WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
   VideoSendParameters new_params = send_params_;
   new_params.options.SetAll(options);
   SetSendParameters(send_params_);
 }
 
 void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
   MediaChannel::SetInterface(iface);
   // Set the RTP recv/send buffer to a bigger size
@@ skipping 738 matching lines @@
       default_stream_(default_stream),
       config_(config),
       external_decoder_factory_(external_decoder_factory),
       disable_prerenderer_smoothing_(disable_prerenderer_smoothing),
       sink_(NULL),
       last_width_(-1),
       last_height_(-1),
       first_frame_timestamp_(-1),
       estimated_remote_start_ntp_time_ms_(0) {
   config_.renderer = this;
-  // SetRecvCodecs will also reset (start) the VideoReceiveStream.
-  LOG(LS_INFO) << "SetRecvCodecs (recv) because we are creating the receive "
-                  "stream for the first time: "
-               << CodecSettingsVectorToString(recv_codecs);
-  SetRecvCodecs(recv_codecs);
+  std::vector<AllocatedDecoder> old_decoders;
+  ConfigureCodecs(recv_codecs, &old_decoders);
+  RecreateWebRtcStream();
+  RTC_DCHECK(old_decoders.empty());
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder::
     AllocatedDecoder(webrtc::VideoDecoder* decoder,
                      webrtc::VideoCodecType type,
                      bool external)
     : decoder(decoder),
       external_decoder(nullptr),
       type(type),
       external(external) {
@@ skipping 51 matching lines @@
     return AllocatedDecoder(
         webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false);
   }
 
   // This shouldn't happen, we should not be trying to create something we don't
   // support.
   RTC_DCHECK(false);
   return AllocatedDecoder(NULL, webrtc::kVideoCodecUnknown, false);
 }
 
-void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
-    const std::vector<VideoCodecSettings>& recv_codecs) {
-  std::vector<AllocatedDecoder> old_decoders = allocated_decoders_;
+void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ConfigureCodecs(
+    const std::vector<VideoCodecSettings>& recv_codecs,
+    std::vector<AllocatedDecoder>* old_decoders) {
+  *old_decoders = allocated_decoders_;
   allocated_decoders_.clear();
   config_.decoders.clear();
   for (size_t i = 0; i < recv_codecs.size(); ++i) {
     AllocatedDecoder allocated_decoder =
-        CreateOrReuseVideoDecoder(&old_decoders, recv_codecs[i].codec);
+        CreateOrReuseVideoDecoder(old_decoders, recv_codecs[i].codec);
     allocated_decoders_.push_back(allocated_decoder);
 
     webrtc::VideoReceiveStream::Decoder decoder;
     decoder.decoder = allocated_decoder.decoder;
     decoder.payload_type = recv_codecs[i].codec.id;
     decoder.payload_name = recv_codecs[i].codec.name;
     config_.decoders.push_back(decoder);
   }
 
   // TODO(pbos): Reconfigure RTX based on incoming recv_codecs.
   config_.rtp.fec = recv_codecs.front().fec;
   config_.rtp.nack.rtp_history_ms =
       HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
-
-  LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvCodecs: "
-               << CodecSettingsVectorToString(recv_codecs);
-  RecreateWebRtcStream();
-  ClearDecoders(&old_decoders);
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
     uint32_t local_ssrc) {
   // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You
   // should not be able to create a sender with the same SSRC as a receiver, but
   // right now this can't be done due to unittests depending on receiving what
   // they are sending from the same MediaChannel.
   if (local_ssrc == config_.rtp.remote_ssrc) {
     LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
@@ skipping 26 matching lines @@
   config_.rtp.remb = remb_enabled;
   config_.rtp.nack.rtp_history_ms = nack_history_ms;
   config_.rtp.transport_cc = transport_cc_enabled;
   LOG(LS_INFO)
       << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack="
       << nack_enabled << ", remb=" << remb_enabled
       << ", transport_cc=" << transport_cc_enabled;
   RecreateWebRtcStream();
 }
 
-void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRtpExtensions(
-    const std::vector<webrtc::RtpExtension>& extensions) {
-  config_.rtp.extensions = extensions;
-  LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of 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();
+    const ChangedRecvParameters& params) {
+  bool needs_recreation = false;
+  std::vector<AllocatedDecoder> old_decoders;
+  if (params.codec_settings) {
+    ConfigureCodecs(*params.codec_settings, &old_decoders);
+    needs_recreation = true;
+  }
+  if (params.rtp_header_extensions) {
+    config_.rtp.extensions = *params.rtp_header_extensions;
+    needs_recreation = true;
+  }
+  if (params.rtcp_mode) {
+    config_.rtp.rtcp_mode = *params.rtcp_mode;
+    needs_recreation = true;
+  }
+  if (needs_recreation) {
+    LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvParameters";
+    RecreateWebRtcStream();
+    ClearDecoders(&old_decoders);
+  }
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
   if (stream_ != NULL) {
     call_->DestroyVideoReceiveStream(stream_);
   }
   stream_ = call_->CreateVideoReceiveStream(config_);
   stream_->Start();
 }
 
@@ skipping 219 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO