Rebased changes to apply VideoOptions per stream.

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 37 matching lines @@
 #include "webrtc/call.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/video_decoder.h"
 #include "webrtc/video_encoder.h"
 
 namespace cricket {
 namespace {
 
+// Default values, used when options are unset.
+const bool kDefault_suspend_below_min_bitrate = false;
+const int kDefault_screencast_min_bitrate_kbps = 0;
+
 // Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory.
 class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
  public:
   // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned
   // by e.g. PeerConnectionFactory.
   explicit EncoderFactoryAdapter(cricket::WebRtcVideoEncoderFactory* factory)
       : factory_(factory) {}
   virtual ~EncoderFactoryAdapter() {}
 
   // Implement webrtc::VideoEncoderFactory.
@@ skipping 570 matching lines @@
 }
 
 WebRtcVideoChannel2::WebRtcVideoChannel2(
     webrtc::Call* call,
     const VideoOptions& options,
     const std::vector<VideoCodec>& recv_codecs,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
     : call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
+      signal_cpu_adaptation_(true),
+      disable_prerenderer_smoothing_(false),
       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;
+
+  SetSharedOptions(options);
+  send_params_.options = options;
+
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   default_send_ssrc_ = 0;
   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_kbps = rtc::Optional<int>(0);
-}
-
 WebRtcVideoChannel2::~WebRtcVideoChannel2() {
   for (auto& kv : send_streams_)
     delete kv.second;
   for (auto& kv : receive_streams_)
     delete kv.second;
 }
 
 bool WebRtcVideoChannel2::CodecIsExternallySupported(
     const std::string& name) const {
   if (external_encoder_factory_ == NULL) {
@@ skipping 92 matching lines @@
   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);
   }
 
   // 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_;
+
+  // Keep the default options. TODO(nisse): This is a bit convoluted.
+  // It might be cleaner to change SetDefaultOptions to only set
+  // options with no current value. Or delete SetDefaultOptions; I
+  // think the problem is references to suspend_below_min_bitrate and
+  // screencast_min_bitrate which require values to be set, but those
+  // references could be changed to use .value_or(the_default_value)
+  // instead.
+
+  VideoOptions new_options = send_params_.options;
   new_options.SetAll(params.options);
-  if (!(new_options == options_)) {
+  if (!(new_options == send_params_.options)) {
     changed_params->options = rtc::Optional<VideoOptions>(new_options);
   }
+#if 0
+  send_params_.options = new_options;
+#endif
 
   // 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);
   }
 
+#if 0
+  SetSharedOptions(params.options);
+  // TODO(nisse): Call each stream's SetSendParameters only for
+  // changed parameters? Used to check params.rtcp.reduced_size, but
+  // that broke the
+  // WebRtcVideoChannel2Test.SetOptionsWithSuspendBelowMinBitrate
+  // test.
+
+  VideoOptions options = send_params_.options;
+  send_params_ = params;
+
+  // Take care to keep old values of options, if the new params
+  // doesn't specify any value.
+  options.SetAll(params.options);
+  send_params_.options = options;
+
+  SetSharedOptions(send_params_.options);
+  // Call each stream's SetSendParameters method. Leaves to the callee
+  // to check if there's any change.
+
+  {
+    rtc::CritScope stream_lock(&stream_crit_);
+    for (auto& kv : send_streams_) {
+      kv.second->SetSendParameters(params);
+    }
+  }
+#endif
+
   return true;
 }
 
 bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendParameters");
   LOG(LS_INFO) << "SetSendParameters: " << params.ToString();
+  // TODO(nisse): Should GetChangedSendParameters call SetSharedOptions?
   ChangedSendParameters changed_params;
   if (!GetChangedSendParameters(params, &changed_params)) {
     return false;
   }
 
   bool bitrate_config_changed = false;
 
   if (changed_params.codec) {
     const VideoCodecSettings& codec_settings = *changed_params.codec;
     send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings);
@@ skipping 21 matching lines @@
         bitrate_config_.min_bitrate_bps > max_bitrate_bps) {
       bitrate_config_.min_bitrate_bps = max_bitrate_bps;
     }
     bitrate_config_changed = true;
   }
 
   if (bitrate_config_changed) {
     call_->SetBitrateConfig(bitrate_config_);
   }
 
+#if 0
   if (changed_params.options) {
     options_.SetAll(*changed_params.options);
     {
       rtc::CritScope lock(&capturer_crit_);
       if (options_.cpu_overuse_detection) {
         signal_cpu_adaptation_ = *options_.cpu_overuse_detection;
       }
     }
     rtc::DiffServCodePoint dscp =
         options_.dscp.value_or(false) ? rtc::DSCP_AF41 : rtc::DSCP_DEFAULT;
     MediaChannel::SetDscp(dscp);
   }
-
+#endif
   {
     rtc::CritScope stream_lock(&stream_crit_);
     for (auto& kv : send_streams_) {
       kv.second->SetSendParameters(changed_params);
     }
     if (changed_params.codec) {
       // Update receive feedback parameters from new codec.
       LOG(LS_INFO)
           << "SetFeedbackOptions on all the receive streams because the send "
              "codec has changed.";
@@ skipping 138 matching lines @@
   LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable
                << "options: " << (options ? options->ToString() : "nullptr")
                << ").";
 
   // TODO(solenberg): The state change should be fully rolled back if any one of
   //                  these calls fail.
   if (!MuteStream(ssrc, !enable)) {
     return false;
   }
   if (enable && options) {
+    // TODO(nisse): Rebase problem.
+#if 0
     VideoSendParameters new_params = send_params_;
     new_params.options.SetAll(*options);
     SetSendParameters(send_params_);
+#else
+    return SetOptions(ssrc, *options);
+#endif
   }
   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 24 matching lines @@
   if (!ValidateSendSsrcAvailability(sp))
     return false;
 
   for (uint32_t used_ssrc : sp.ssrcs)
     send_ssrcs_.insert(used_ssrc);
 
   webrtc::VideoSendStream::Config config(this);
   config.overuse_callback = this;
 
   WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
-      call_, sp, config, external_encoder_factory_, options_,
+      call_, sp, config, external_encoder_factory_,
       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 "
@@ skipping 109 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_, options_.disable_prerenderer_smoothing.value_or(false));
+      recv_codecs_, 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 245 matching lines @@
   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;
 }
 
 // TODO(pbos): Remove SetOptions in favor of SetSendParameters.
+#if 0
+// TODO(nisse): Rebase leftover.
 void WebRtcVideoChannel2::SetOptions(const VideoOptions& options) {
   VideoSendParameters new_params = send_params_;
   new_params.options.SetAll(options);
   SetSendParameters(send_params_);
 }
+#endif
+void WebRtcVideoChannel2::SetSharedOptions(const VideoOptions& options) {
+  {
+    rtc::CritScope lock(&capturer_crit_);
+    if (options.cpu_overuse_detection)
+      signal_cpu_adaptation_ = *options.cpu_overuse_detection;
+  }
+  if (options.disable_prerenderer_smoothing)
+    disable_prerenderer_smoothing_ = *options.disable_prerenderer_smoothing;
+
+  if (options.dscp) {
+    rtc::DiffServCodePoint dscp =
+        *options.dscp ? rtc::DSCP_AF41 : rtc::DSCP_DEFAULT;
+    MediaChannel::SetDscp(dscp);
+  }
+}
+
+bool WebRtcVideoChannel2::SetOptions(uint32_t ssrc,
+                                     const VideoOptions& options) {
+  TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetOptions");
+  LOG(LS_INFO) << "SetOptions: ssrc " << ssrc << ": " << options.ToString();
+  SetSharedOptions(options);
+
+  rtc::CritScope stream_lock(&stream_crit_);
+  if (send_streams_.find(ssrc) == send_streams_.end()) {
+    return false;
+  }
+  send_streams_[ssrc]->SetOptions(options);
+
+  return true;
+}
 
 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
@@ skipping 88 matching lines @@
     this->encoder =
         new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
     const StreamParams& sp,
     const webrtc::VideoSendStream::Config& config,
     WebRtcVideoEncoderFactory* external_encoder_factory,
-    const VideoOptions& options,
     int max_bitrate_bps,
     const rtc::Optional<VideoCodecSettings>& codec_settings,
     const std::vector<webrtc::RtpExtension>& rtp_extensions,
     // TODO(deadbeef): 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),
       external_encoder_factory_(external_encoder_factory),
       stream_(NULL),
-      parameters_(config, options, max_bitrate_bps, codec_settings),
+      parameters_(config, send_params.options, max_bitrate_bps, codec_settings),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
       capturer_(NULL),
       sending_(false),
       muted_(false),
       old_adapt_changes_(0),
       first_frame_timestamp_ms_(0),
       last_frame_timestamp_ms_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
 
@@ skipping 270 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;
 
-  RTC_CHECK(options.suspend_below_min_bitrate);
   parameters_.config.suspend_below_min_bitrate =
-      *options.suspend_below_min_bitrate;
+      options.suspend_below_min_bitrate.value_or(
+          kDefault_suspend_below_min_bitrate);
 
   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) {
@@ skipping 45 matching lines @@
     RecreateWebRtcStream();
   }
 }
 
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const Dimensions& dimensions,
     const VideoCodec& codec) const {
   webrtc::VideoEncoderConfig encoder_config;
   if (dimensions.is_screencast) {
-    RTC_CHECK(parameters_.options.screencast_min_bitrate_kbps);
     encoder_config.min_transmit_bitrate_bps =
-        *parameters_.options.screencast_min_bitrate_kbps * 1000;
+        1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(
+            kDefault_screencast_min_bitrate_kbps);
     encoder_config.content_type =
         webrtc::VideoEncoderConfig::ContentType::kScreen;
   } else {
     encoder_config.min_transmit_bitrate_bps = 0;
     encoder_config.content_type =
         webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
   }
 
   // Restrict dimensions according to codec max.
   int width = dimensions.width;
@@ skipping 653 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO