Move suspend_below_min_bitrate from VideoOptions to MediaConfig.

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 594 matching lines @@
 WebRtcVideoChannel2::WebRtcVideoChannel2(
     webrtc::Call* call,
     const MediaConfig& config,
     const VideoOptions& options,
     const std::vector<VideoCodec>& recv_codecs,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
-      signal_cpu_adaptation_(config.enable_cpu_overuse_detection),
-      disable_prerenderer_smoothing_(config.disable_prerenderer_smoothing),
+      video_config_(config.video),
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   send_params_.options = options;
 
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   default_send_ssrc_ = 0;
   RTC_DCHECK(ValidateCodecFormats(recv_codecs));
@@ skipping 367 matching lines @@
 
   rtc::CritScope stream_lock(&stream_crit_);
 
   if (!ValidateSendSsrcAvailability(sp))
     return false;
 
   for (uint32_t used_ssrc : sp.ssrcs)
     send_ssrcs_.insert(used_ssrc);
 
   webrtc::VideoSendStream::Config config(this);
-  WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
-      call_, sp, config, external_encoder_factory_, signal_cpu_adaptation_,
-      bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
-      send_params_);
+  config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate;
+  WebRtcVideoSendStream* stream =
+      new WebRtcVideoSendStream(call_, sp, config, external_encoder_factory_,
+                                video_config_.enable_cpu_overuse_detection,
+                                bitrate_config_.max_bitrate_bps, send_codec_,
+                                send_rtp_extensions_, send_params_);
 
   uint32_t ssrc = sp.first_ssrc();
   RTC_DCHECK(ssrc != 0);
   send_streams_[ssrc] = stream;
 
   if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
     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_)
@@ skipping 107 matching lines @@
 
   // Set up A/V sync group based on sync label.
   config.sync_group = sp.sync_label;
 
   config.rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false;
   config.rtp.transport_cc =
       send_codec_ ? HasTransportCc(send_codec_->codec) : false;
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
       call_, sp, config, external_decoder_factory_, default_stream,
-      recv_codecs_, disable_prerenderer_smoothing_);
+      recv_codecs_, video_config_.disable_prerenderer_smoothing);
 
   return true;
 }
 
 void WebRtcVideoChannel2::ConfigureReceiverRtp(
     webrtc::VideoReceiveStream::Config* config,
     const StreamParams& sp) const {
   uint32_t ssrc = sp.first_ssrc();
 
   config->rtp.remote_ssrc = ssrc;
@@ skipping 356 matching lines @@
                  &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;
   parameters_.config.overuse_callback =
       enable_cpu_overuse_detection ? this : nullptr;
 
   if (codec_settings) {
-    SetCodecAndOptions(*codec_settings, parameters_.options);
+    SetCodec(*codec_settings);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
   DisconnectCapturer();
   if (stream_ != NULL) {
     call_->DestroyVideoSendStream(stream_);
   }
   DestroyVideoEncoder(&allocated_encoder_);
 }
@@ skipping 118 matching lines @@
 }
 
 const std::vector<uint32_t>&
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
   return ssrcs_;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
     const VideoOptions& options) {
   rtc::CritScope cs(&lock_);
-  if (parameters_.codec_settings) {
-    LOG(LS_INFO) << "SetCodecAndOptions because of SetOptions; options="
-                 << options.ToString();
-    SetCodecAndOptions(*parameters_.codec_settings, options);
-  } else {
-    parameters_.options = options;
-  }
+  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;
   }
@@ skipping 36 matching lines @@
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
     AllocatedEncoder* encoder) {
   if (encoder->external) {
     external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
   }
   delete encoder->encoder;
 }
 
-void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
-    const VideoCodecSettings& codec_settings,
-    const VideoOptions& options) {
+void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
+    const VideoCodecSettings& codec_settings) {
   parameters_.encoder_config =
       CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
   RTC_DCHECK(!parameters_.encoder_config.streams.empty());
 
   AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec);
   parameters_.config.encoder_settings.encoder = new_encoder.encoder;
   parameters_.config.encoder_settings.full_overuse_time = new_encoder.external;
   parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
   parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
   if (new_encoder.external) {
@@ skipping 10 matching lines @@
                          "payload type. Ignoring.";
       parameters_.config.rtp.rtx.ssrcs.clear();
     } else {
       parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type;
     }
   }
 
   parameters_.config.rtp.nack.rtp_history_ms =
       HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
 
-  parameters_.config.suspend_below_min_bitrate =
-      options.suspend_below_min_bitrate.value_or(false);
-
   parameters_.codec_settings =
       rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings);
-  parameters_.options = options;
-
-  LOG(LS_INFO)
-      << "RecreateWebRtcStream (send) because of SetCodecAndOptions; options="
-      << options.ToString();
   RecreateWebRtcStream();
   if (allocated_encoder_.encoder != new_encoder.encoder) {
     DestroyVideoEncoder(&allocated_encoder_);
     allocated_encoder_ = new_encoder;
   }
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters(
     const ChangedSendParameters& params) {
   rtc::CritScope cs(&lock_);
@@ skipping 15 matching lines @@
   }
   if (params.max_bandwidth_bps) {
     // Max bitrate has changed, reconfigure encoder settings on the next frame
     // or stream recreation.
     parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
     pending_encoder_reconfiguration_ = true;
   }
   if (params.conference_mode) {
     parameters_.conference_mode = *params.conference_mode;
   }
+  if (params.options)
+    SetOptions(*params.options);
+
   // Set codecs and options.
   if (params.codec) {
-    SetCodecAndOptions(*params.codec,
-                       params.options ? *params.options : parameters_.options);
+    SetCodec(*params.codec);
     return;
-  } else if (params.options) {
-    // Reconfigure if codecs are already set.
-    if (parameters_.codec_settings) {
-      SetCodecAndOptions(*parameters_.codec_settings, *params.options);
-      return;
-    } else {
-      parameters_.options = *params.options;
-    }
   } else if (params.conference_mode && parameters_.codec_settings) {
-    SetCodecAndOptions(*parameters_.codec_settings, parameters_.options);
+    SetCodec(*parameters_.codec_settings);
     return;
   }
   if (recreate_stream) {
     LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
     RecreateWebRtcStream();
   }
 }
 
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
@@ skipping 717 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