New flag is_screencast in VideoOptions.

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 393 matching lines @@
 
   int max_qp = kDefaultQpMax;
   codec.GetParam(kCodecParamMaxQuantization, &max_qp);
   stream.max_qp = max_qp;
   std::vector<webrtc::VideoStream> streams;
   streams.push_back(stream);
   return streams;
 }
 
 void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
-    const VideoCodec& codec,
-    const VideoOptions& options,
-    bool is_screencast) {
+    const VideoCodec& codec) {
+  bool is_screencast = parameters_.options.is_screencast.value_or(false);
   // No automatic resizing when using simulcast or screencast.
   bool automatic_resize =
       !is_screencast && parameters_.config.rtp.ssrcs.size() == 1;
   bool frame_dropping = !is_screencast;
   bool denoising;
   bool codec_default_denoising = false;
   if (is_screencast) {
     denoising = false;
   } else {
     // Use codec default if video_noise_reduction is unset.
-    codec_default_denoising = !options.video_noise_reduction;
-    denoising = options.video_noise_reduction.value_or(false);
+    codec_default_denoising = !parameters_.options.video_noise_reduction;
+    denoising = parameters_.options.video_noise_reduction.value_or(false);
   }
 
   if (CodecNamesEq(codec.name, kH264CodecName)) {
     encoder_settings_.h264 = webrtc::VideoEncoder::GetDefaultH264Settings();
     encoder_settings_.h264.frameDroppingOn = frame_dropping;
     return &encoder_settings_.h264;
   }
   if (CodecNamesEq(codec.name, kVp8CodecName)) {
     encoder_settings_.vp8 = webrtc::VideoEncoder::GetDefaultVp8Settings();
     encoder_settings_.vp8.automaticResizeOn = automatic_resize;
@@ skipping 1044 matching lines @@
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       cpu_restricted_counter_(0),
       number_of_cpu_adapt_changes_(0),
       capturer_(nullptr),
       external_encoder_factory_(external_encoder_factory),
       stream_(nullptr),
       parameters_(config, send_params.options, max_bitrate_bps, codec_settings),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false),
-      capturer_is_screencast_(false),
       sending_(false),
       muted_(false),
       first_frame_timestamp_ms_(0),
       last_frame_timestamp_ms_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
   parameters_.conference_mode = send_params.conference_mode;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
   sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
                  &parameters_.config.rtp.rtx.ssrcs);
@@ skipping 59 matching lines @@
 
   int64_t frame_delta_ms = frame.GetTimeStamp() / rtc::kNumNanosecsPerMillisec;
   // frame->GetTimeStamp() is essentially a delta, align to webrtc time
   if (first_frame_timestamp_ms_ == 0) {
     first_frame_timestamp_ms_ = rtc::Time() - frame_delta_ms;
   }
 
   last_frame_timestamp_ms_ = first_frame_timestamp_ms_ + frame_delta_ms;
   video_frame.set_render_time_ms(last_frame_timestamp_ms_);
   // Reconfigure codec if necessary.
-  SetDimensions(video_frame.width(), video_frame.height(),
-                capturer_is_screencast_);
+  SetDimensions(video_frame.width(), video_frame.height());
   last_rotation_ = video_frame.rotation();
 
   stream_->Input()->IncomingCapturedFrame(video_frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
     VideoCapturer* capturer) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetCapturer");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!DisconnectCapturer() && capturer == NULL) {
@@ skipping 21 matching lines @@
         // 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;
     }
-    capturer_is_screencast_ = capturer->IsScreencast();
   }
   capturer_ = capturer;
   capturer_->AddOrUpdateSink(this, sink_wants_);
   return true;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
   rtc::CritScope cs(&lock_);
   muted_ = mute;
 }
@@ skipping 15 matching lines @@
 }
 
 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)) {
@@ skipping 74 matching lines @@
     } 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_.codec_settings =
       rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings);
+
+  LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec.";
   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 37 matching lines @@
     LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
     RecreateWebRtcStream();
   }
 }
 
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const Dimensions& dimensions,
     const VideoCodec& codec) const {
   webrtc::VideoEncoderConfig encoder_config;
-  if (dimensions.is_screencast) {
+  bool is_screencast = parameters_.options.is_screencast.value_or(false);
+  if (is_screencast) {
     encoder_config.min_transmit_bitrate_bps =
         1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0);
     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;
   int height = dimensions.height;
-  if (!dimensions.is_screencast) {
+  if (!is_screencast) {
     if (codec.width < width)
       width = codec.width;
     if (codec.height < height)
       height = codec.height;
   }
 
   VideoCodec clamped_codec = codec;
   clamped_codec.width = width;
   clamped_codec.height = height;
 
   // By default, the stream count for the codec configuration should match the
   // number of negotiated ssrcs. But if the codec is blacklisted for simulcast
   // or a screencast, only configure a single stream.
   size_t stream_count = parameters_.config.rtp.ssrcs.size();
-  if (IsCodecBlacklistedForSimulcast(codec.name) || dimensions.is_screencast) {
+  if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) {
     stream_count = 1;
   }
 
   encoder_config.streams =
       CreateVideoStreams(clamped_codec, parameters_.options,
                          parameters_.max_bitrate_bps, stream_count);
 
   // Conference mode screencast uses 2 temporal layers split at 100kbit.
-  if (parameters_.conference_mode && dimensions.is_screencast &&
+  if (parameters_.conference_mode && is_screencast &&
       encoder_config.streams.size() == 1) {
     ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault();
 
     // For screenshare in conference mode, tl0 and tl1 bitrates are piggybacked
     // on the VideoCodec struct as target and max bitrates, respectively.
     // See eg. webrtc::VP8EncoderImpl::SetRates().
     encoder_config.streams[0].target_bitrate_bps =
         config.tl0_bitrate_kbps * 1000;
     encoder_config.streams[0].max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
     encoder_config.streams[0].temporal_layer_thresholds_bps.clear();
     encoder_config.streams[0].temporal_layer_thresholds_bps.push_back(
         config.tl0_bitrate_kbps * 1000);
   }
   return encoder_config;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
     int width,
-    int height,
-    bool is_screencast) {
+    int height) {
   if (last_dimensions_.width == width && last_dimensions_.height == height &&
-      last_dimensions_.is_screencast == is_screencast &&
       !pending_encoder_reconfiguration_) {
     // Configured using the same parameters, do not reconfigure.
     return;
   }
-  LOG(LS_INFO) << "SetDimensions: " << width << "x" << height
-               << (is_screencast ? " (screencast)" : " (not screencast)");
 
   last_dimensions_.width = width;
   last_dimensions_.height = height;
-  last_dimensions_.is_screencast = is_screencast;
 
   RTC_DCHECK(!parameters_.encoder_config.streams.empty());
 
   RTC_CHECK(parameters_.codec_settings);
   VideoCodecSettings codec_settings = *parameters_.codec_settings;
 
   webrtc::VideoEncoderConfig encoder_config =
       CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
 
   encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
-      codec_settings.codec, parameters_.options, is_screencast);
+      codec_settings.codec);
 
   bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
 
   encoder_config.encoder_specific_settings = NULL;
   pending_encoder_reconfiguration_ = false;
 
   if (!stream_reconfigured) {
-    LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
-                    << width << "x" << height;
     return;
   }
 
   parameters_.encoder_config = encoder_config;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
   rtc::CritScope cs(&lock_);
   RTC_DCHECK(stream_ != NULL);
   stream_->Start();
@@ skipping 10 matching lines @@
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate(Load load) {
   if (worker_thread_ != rtc::Thread::Current()) {
     invoker_.AsyncInvoke<void>(
         worker_thread_,
         rtc::Bind(&WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate,
                   this, load));
     return;
   }
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  LOG(LS_INFO) << "OnLoadUpdate " << load;
   if (!capturer_) {
     return;
   }
   {
     rtc::CritScope cs(&lock_);
+    LOG(LS_INFO) << "OnLoadUpdate " << load << ", is_screencast: "
+                 << (parameters_.options.is_screencast
+                         ? (*parameters_.options.is_screencast ? "true"
+                                                               : "false")
+                         : "unset");
     // Do not adapt resolution for screen content as this will likely result in
     // blurry and unreadable text.
-    if (capturer_is_screencast_)
+    if (parameters_.options.is_screencast.value_or(false))
       return;
 
     rtc::Optional<int> max_pixel_count;
     rtc::Optional<int> max_pixel_count_step_up;
     if (load == kOveruse) {
         max_pixel_count = rtc::Optional<int>(
             (last_dimensions_.height * last_dimensions_.width) / 2);
       // Increase |number_of_cpu_adapt_changes_| if
       // sink_wants_.max_pixel_count will be changed since
       // last time |capturer_->AddOrUpdateSink| was called. That is, this will
@@ skipping 130 matching lines @@
   bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
   bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
   if (stream_ != NULL) {
     call_->DestroyVideoSendStream(stream_);
   }
 
   RTC_CHECK(parameters_.codec_settings);
+  RTC_DCHECK_EQ((parameters_.encoder_config.content_type ==
+                 webrtc::VideoEncoderConfig::ContentType::kScreen),
+                parameters_.options.is_screencast.value_or(false))
+      << "encoder content type inconsistent with screencast option";
   parameters_.encoder_config.encoder_specific_settings =
-      ConfigureVideoEncoderSettings(
-          parameters_.codec_settings->codec, parameters_.options,
-          parameters_.encoder_config.content_type ==
-              webrtc::VideoEncoderConfig::ContentType::kScreen);
+      ConfigureVideoEncoderSettings(parameters_.codec_settings->codec);
 
   webrtc::VideoSendStream::Config config = parameters_.config;
   if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) {
     LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX "
                        "payload type the set codec. Ignoring RTX.";
     config.rtp.rtx.ssrcs.clear();
   }
   stream_ = call_->CreateVideoSendStream(config, parameters_.encoder_config);
 
   parameters_.encoder_config.encoder_specific_settings = NULL;
@@ skipping 419 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