Revert of Let ViEEncoder handle resolution changes.

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.
  */
 
 #include "webrtc/media/engine/webrtcvideoengine2.h"
 
 #include <stdio.h>
 #include <algorithm>
 #include <set>
 #include <string>
-#include <utility>
 
 #include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call.h"
 #include "webrtc/media/engine/constants.h"
 #include "webrtc/media/engine/simulcast.h"
 #include "webrtc/media/engine/webrtcmediaengine.h"
@@ skipping 288 matching lines @@
 }
 
 int GetDefaultVp9TemporalLayers() {
   int num_sl;
   int num_tl;
   if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) {
     return num_tl;
   }
   return 1;
 }
-
-class EncoderStreamFactory
-    : public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface {
- public:
-  EncoderStreamFactory(std::string codec_name,
-                       int max_qp,
-                       int max_framerate,
-                       bool is_screencast,
-                       bool conference_mode)
-      : codec_name_(codec_name),
-        max_qp_(max_qp),
-        max_framerate_(max_framerate),
-        is_screencast_(is_screencast),
-        conference_mode_(conference_mode) {}
-
- private:
-  std::vector<webrtc::VideoStream> CreateEncoderStreams(
-      int width,
-      int height,
-      const webrtc::VideoEncoderConfig& encoder_config) override {
-    RTC_DCHECK(encoder_config.number_of_streams > 1 ? !is_screencast_ : true);
-    if (encoder_config.number_of_streams > 1) {
-      return GetSimulcastConfig(encoder_config.number_of_streams, width, height,
-                                encoder_config.max_bitrate_bps, max_qp_,
-                                max_framerate_);
-    }
-
-    // For unset max bitrates set default bitrate for non-simulcast.
-    int max_bitrate_bps =
-        (encoder_config.max_bitrate_bps > 0)
-            ? encoder_config.max_bitrate_bps
-            : GetMaxDefaultVideoBitrateKbps(width, height) * 1000;
-
-    webrtc::VideoStream stream;
-    stream.width = width;
-    stream.height = height;
-    stream.max_framerate = max_framerate_;
-    stream.min_bitrate_bps = kMinVideoBitrateKbps * 1000;
-    stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
-    stream.max_qp = max_qp_;
-
-    // Conference mode screencast uses 2 temporal layers split at 100kbit.
-    if (conference_mode_ && is_screencast_) {
-      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().
-      stream.target_bitrate_bps = config.tl0_bitrate_kbps * 1000;
-      stream.max_bitrate_bps = config.tl1_bitrate_kbps * 1000;
-      stream.temporal_layer_thresholds_bps.clear();
-      stream.temporal_layer_thresholds_bps.push_back(config.tl0_bitrate_kbps *
-                                                     1000);
-    }
-
-    if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) {
-      stream.temporal_layer_thresholds_bps.resize(
-          GetDefaultVp9TemporalLayers() - 1);
-    }
-
-    std::vector<webrtc::VideoStream> streams;
-    streams.push_back(stream);
-    return streams;
-  }
-
-  const std::string codec_name_;
-  const int max_qp_;
-  const int max_framerate_;
-  const bool is_screencast_;
-  const bool conference_mode_;
-};
-
 }  // namespace
 
 // Constants defined in webrtc/media/engine/constants.h
 // TODO(pbos): Move these to a separate constants.cc file.
-const int kMinVideoBitrateKbps = 30;
+const int kMinVideoBitrate = 30;
+const int kStartVideoBitrate = 300;
 
 const int kVideoMtu = 1200;
 const int kVideoRtpBufferSize = 65536;
 
 // This constant is really an on/off, lower-level configurable NACK history
 // duration hasn't been implemented.
 static const int kNackHistoryMs = 1000;
 
 static const int kDefaultQpMax = 56;
 
@@ skipping 50 matching lines @@
     codec.SetParam(kH264FmtpLevelAsymmetryAllowed, "1");
     codec.SetParam(kH264FmtpPacketizationMode, "1");
     AddCodecAndMaybeRtxCodec(codec, &codecs);
   }
   AddCodecAndMaybeRtxCodec(VideoCodec(kDefaultRedPlType, kRedCodecName),
                            &codecs);
   codecs.push_back(VideoCodec(kDefaultUlpfecType, kUlpfecCodecName));
   return codecs;
 }
 
+std::vector<webrtc::VideoStream>
+WebRtcVideoChannel2::WebRtcVideoSendStream::CreateSimulcastVideoStreams(
+    const VideoCodec& codec,
+    const VideoOptions& options,
+    int max_bitrate_bps,
+    size_t num_streams) {
+  int max_qp = kDefaultQpMax;
+  codec.GetParam(kCodecParamMaxQuantization, &max_qp);
+
+  return GetSimulcastConfig(
+      num_streams, codec.width, codec.height, max_bitrate_bps, max_qp,
+      codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate);
+}
+
+std::vector<webrtc::VideoStream>
+WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoStreams(
+    const VideoCodec& codec,
+    const VideoOptions& options,
+    int max_bitrate_bps,
+    size_t num_streams) {
+  int codec_max_bitrate_kbps;
+  if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
+    max_bitrate_bps = codec_max_bitrate_kbps * 1000;
+  }
+  if (num_streams != 1) {
+    return CreateSimulcastVideoStreams(codec, options, max_bitrate_bps,
+                                       num_streams);
+  }
+
+  // For unset max bitrates set default bitrate for non-simulcast.
+  if (max_bitrate_bps <= 0) {
+    max_bitrate_bps =
+        GetMaxDefaultVideoBitrateKbps(codec.width, codec.height) * 1000;
+  }
+
+  webrtc::VideoStream stream;
+  stream.width = codec.width;
+  stream.height = codec.height;
+  stream.max_framerate =
+      codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
+
+  stream.min_bitrate_bps = kMinVideoBitrate * 1000;
+  stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
+
+  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;
+}
+
 rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
 WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
     const VideoCodec& codec) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   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 {
@@ skipping 1070 matching lines @@
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
     VideoSendStreamParameters(
         webrtc::VideoSendStream::Config config,
         const VideoOptions& options,
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings)
     : config(std::move(config)),
       options(options),
       max_bitrate_bps(max_bitrate_bps),
-      conference_mode(false),
       codec_settings(codec_settings) {}
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
     webrtc::VideoEncoder* encoder,
     webrtc::VideoCodecType type,
     bool external)
     : encoder(encoder),
       external_encoder(nullptr),
       type(type),
       external(external) {
@@ skipping 24 matching lines @@
       cpu_restricted_counter_(0),
       number_of_cpu_adapt_changes_(0),
       frame_count_(0),
       cpu_restricted_frame_count_(0),
       source_(nullptr),
       external_encoder_factory_(external_encoder_factory),
       stream_(nullptr),
       encoder_sink_(nullptr),
       parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
+      pending_encoder_reconfiguration_(false),
       allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false),
       sending_(false),
       last_frame_timestamp_us_(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);
   parameters_.config.rtp.c_name = sp.cname;
@@ skipping 47 matching lines @@
   rtc::CritScope cs(&lock_);
 
   if (video_frame.width() != last_frame_info_.width ||
       video_frame.height() != last_frame_info_.height ||
       video_frame.rotation() != last_frame_info_.rotation ||
       video_frame.is_texture() != last_frame_info_.is_texture) {
     last_frame_info_.width = video_frame.width();
     last_frame_info_.height = video_frame.height();
     last_frame_info_.rotation = video_frame.rotation();
     last_frame_info_.is_texture = video_frame.is_texture();
+    pending_encoder_reconfiguration_ = true;
 
     LOG(LS_INFO) << "Video frame parameters changed: dimensions="
                  << last_frame_info_.width << "x" << last_frame_info_.height
                  << ", rotation=" << last_frame_info_.rotation
                  << ", texture=" << last_frame_info_.is_texture;
   }
 
   if (encoder_sink_ == NULL) {
     // Frame input before send codecs are configured, dropping frame.
     return;
   }
 
   last_frame_timestamp_us_ = video_frame.timestamp_us();
 
+  if (pending_encoder_reconfiguration_) {
+    ReconfigureEncoder();
+    pending_encoder_reconfiguration_ = false;
+  }
+
+  // Not sending, abort after reconfiguration. Reconfiguration should still
+  // occur to permit sending this input as quickly as possible once we start
+  // sending (without having to reconfigure then).
+  if (!sending_) {
+    return;
+  }
+
   ++frame_count_;
   if (cpu_restricted_counter_ > 0)
     ++cpu_restricted_frame_count_;
 
-  // Forward frame to the encoder regardless if we are sending or not. This is
-  // to ensure that the encoder can be reconfigured with the correct frame size
-  // as quickly as possible.
   encoder_sink_->OnFrame(video_frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
     bool enable,
     const VideoOptions* options,
     rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   // Ignore |options| pointer if |enable| is false.
   bool options_present = enable && options;
   bool source_changing = source_ != source;
   if (source_changing) {
     DisconnectSource();
   }
 
-  if (options_present) {
-    VideoOptions old_options = parameters_.options;
-    parameters_.options.SetAll(*options);
-    // If options has changed and SetCodec has been called.
-    if (parameters_.options != old_options && stream_) {
-      ReconfigureEncoder();
+  if (options_present || source_changing) {
+    rtc::CritScope cs(&lock_);
+
+    if (options_present) {
+      VideoOptions old_options = parameters_.options;
+      parameters_.options.SetAll(*options);
+      // Reconfigure encoder settings on the next frame or stream
+      // recreation if the options changed.
+      if (parameters_.options != old_options) {
+        pending_encoder_reconfiguration_ = true;
+      }
+    }
+
+    if (source_changing) {
+      if (source == nullptr && encoder_sink_ != nullptr) {
+        LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
+        // Force this black frame not to be dropped due to timestamp order
+        // check. As IncomingCapturedFrame will drop the frame if this frame's
+        // timestamp is less than or equal to last frame's timestamp, it is
+        // necessary to give this black frame a larger timestamp than the
+        // previous one.
+        last_frame_timestamp_us_ += rtc::kNumMicrosecsPerMillisec;
+        rtc::scoped_refptr<webrtc::I420Buffer> black_buffer(
+            webrtc::I420Buffer::Create(last_frame_info_.width,
+                                       last_frame_info_.height));
+        black_buffer->SetToBlack();
+
+        encoder_sink_->OnFrame(webrtc::VideoFrame(
+            black_buffer, last_frame_info_.rotation, last_frame_timestamp_us_));
+      }
+      source_ = source;
     }
   }
 
-  if (source_changing) {
-    rtc::CritScope cs(&lock_);
-    if (source == nullptr && encoder_sink_ != nullptr &&
-        last_frame_info_.width > 0) {
-      LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
-      // Force this black frame not to be dropped due to timestamp order
-      // check. As IncomingCapturedFrame will drop the frame if this frame's
-      // timestamp is less than or equal to last frame's timestamp, it is
-      // necessary to give this black frame a larger timestamp than the
-      // previous one.
-      last_frame_timestamp_us_ += rtc::kNumMicrosecsPerMillisec;
-      rtc::scoped_refptr<webrtc::I420Buffer> black_buffer(
-          webrtc::I420Buffer::Create(last_frame_info_.width,
-                                     last_frame_info_.height));
-      black_buffer->SetToBlack();
-
-      encoder_sink_->OnFrame(webrtc::VideoFrame(
-          black_buffer, last_frame_info_.rotation, last_frame_timestamp_us_));
-    }
-    source_ = source;
-  }
-
+  // |source_->AddOrUpdateSink| may not be called while holding |lock_| since
+  // that might cause a lock order inversion.
   if (source_changing && source_) {
-    // |source_->AddOrUpdateSink| may not be called while holding |lock_| since
-    // that might cause a lock order inversion.
     source_->AddOrUpdateSink(this, sink_wants_);
   }
   return true;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectSource() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (source_ == nullptr) {
     return;
   }
 
   // |source_->RemoveSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   source_->RemoveSink(this);
   source_ = nullptr;
   // Reset |cpu_restricted_counter_| if the source is changed. It is not
   // possible to know if the video resolution is restricted by CPU usage after
@@ skipping 14 matching lines @@
     return webrtc::kVideoCodecVP9;
   } else if (CodecNamesEq(name, kH264CodecName)) {
     return webrtc::kVideoCodecH264;
   }
   return webrtc::kVideoCodecUnknown;
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder(
     const VideoCodec& codec) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
 
   // Do not re-create encoders of the same type.
   if (type == allocated_encoder_.type && allocated_encoder_.encoder != NULL) {
     return allocated_encoder_;
   }
 
   if (external_encoder_factory_ != NULL) {
     webrtc::VideoEncoder* encoder =
         external_encoder_factory_->CreateVideoEncoder(type);
@@ skipping 14 matching lines @@
   }
 
   // This shouldn't happen, we should not be trying to create something we don't
   // support.
   RTC_DCHECK(false);
   return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false);
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
     AllocatedEncoder* encoder) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   if (encoder->external) {
     external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
   }
   delete encoder->encoder;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
     const VideoCodecSettings& codec_settings) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec);
-  RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0u);
+  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) {
     webrtc::VideoCodecType type = CodecTypeFromName(codec_settings.codec.name);
     parameters_.config.encoder_settings.internal_source =
         external_encoder_factory_->EncoderTypeHasInternalSource(type);
@@ skipping 20 matching lines @@
   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_DCHECK_RUN_ON(&thread_checker_);
-  // |recreate_stream| means construction-time parameters have changed and the
-  // sending stream needs to be reset with the new config.
-  bool recreate_stream = false;
-  if (params.rtcp_mode) {
-    parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
-    recreate_stream = true;
-  }
-  if (params.rtp_header_extensions) {
-    parameters_.config.rtp.extensions = *params.rtp_header_extensions;
-    recreate_stream = true;
-  }
-  if (params.max_bandwidth_bps) {
-    parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
-    ReconfigureEncoder();
-  }
-  if (params.conference_mode) {
-    parameters_.conference_mode = *params.conference_mode;
-  }
+  {
+    rtc::CritScope cs(&lock_);
+    // |recreate_stream| means construction-time parameters have changed and the
+    // sending stream needs to be reset with the new config.
+    bool recreate_stream = false;
+    if (params.rtcp_mode) {
+      parameters_.config.rtp.rtcp_mode = *params.rtcp_mode;
+      recreate_stream = true;
+    }
+    if (params.rtp_header_extensions) {
+      parameters_.config.rtp.extensions = *params.rtp_header_extensions;
+      recreate_stream = true;
+    }
+    if (params.max_bandwidth_bps) {
+      parameters_.max_bitrate_bps = *params.max_bandwidth_bps;
+      pending_encoder_reconfiguration_ = true;
+    }
+    if (params.conference_mode) {
+      parameters_.conference_mode = *params.conference_mode;
+    }
 
-  // Set codecs and options.
-  if (params.codec) {
-    SetCodec(*params.codec);
-    recreate_stream = false;  // SetCodec has already recreated the stream.
-  } else if (params.conference_mode && parameters_.codec_settings) {
-    SetCodec(*parameters_.codec_settings);
-    recreate_stream = false;  // SetCodec has already recreated the stream.
-  }
-  if (recreate_stream) {
-    LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters";
-    RecreateWebRtcStream();
-  }
+    // Set codecs and options.
+    if (params.codec) {
+      SetCodec(*params.codec);
+      recreate_stream = false;  // SetCodec has already recreated the stream.
+    } else if (params.conference_mode && parameters_.codec_settings) {
+      SetCodec(*parameters_.codec_settings);
+      recreate_stream = false;  // SetCodec has already recreated the stream.
+    }
+    if (recreate_stream) {
+      LOG(LS_INFO)
+          << "RecreateWebRtcStream (send) because of SetSendParameters";
+      RecreateWebRtcStream();
+    }
+  }  // release |lock_|
 
   // |source_->AddOrUpdateSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   if (params.rtp_header_extensions) {
     sink_wants_.rotation_applied = !ContainsHeaderExtension(
         *params.rtp_header_extensions, webrtc::RtpExtension::kVideoRotationUri);
     if (source_) {
       source_->AddOrUpdateSink(this, sink_wants_);
     }
   }
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpParameters(
     const webrtc::RtpParameters& new_parameters) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   if (!ValidateRtpParameters(new_parameters)) {
     return false;
   }
 
-  bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps !=
-                             rtp_parameters_.encodings[0].max_bitrate_bps;
+  rtc::CritScope cs(&lock_);
+  if (new_parameters.encodings[0].max_bitrate_bps !=
+      rtp_parameters_.encodings[0].max_bitrate_bps) {
+    pending_encoder_reconfiguration_ = true;
+  }
   rtp_parameters_ = new_parameters;
   // Codecs are currently handled at the WebRtcVideoChannel2 level.
   rtp_parameters_.codecs.clear();
-  if (reconfigure_encoder) {
-    ReconfigureEncoder();
-  }
   // Encoding may have been activated/deactivated.
   UpdateSendState();
   return true;
 }
 
 webrtc::RtpParameters
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetRtpParameters() const {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  rtc::CritScope cs(&lock_);
   return rtp_parameters_;
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::ValidateRtpParameters(
     const webrtc::RtpParameters& rtp_parameters) {
   if (rtp_parameters.encodings.size() != 1) {
     LOG(LS_ERROR)
         << "Attempted to set RtpParameters without exactly one encoding";
     return false;
   }
   return true;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateSendState() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   // TODO(deadbeef): Need to handle more than one encoding in the future.
   RTC_DCHECK(rtp_parameters_.encodings.size() == 1u);
   if (sending_ && rtp_parameters_.encodings[0].active) {
     RTC_DCHECK(stream_ != nullptr);
     stream_->Start();
   } else {
     if (stream_ != nullptr) {
       stream_->Stop();
     }
   }
 }
 
 webrtc::VideoEncoderConfig
 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig(
     const VideoCodec& codec) const {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   webrtc::VideoEncoderConfig encoder_config;
   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 = last_frame_info_.width;
+  int height = last_frame_info_.height;
+  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.
-  encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size();
+  size_t stream_count = parameters_.config.rtp.ssrcs.size();
   if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) {
-    encoder_config.number_of_streams = 1;
+    stream_count = 1;
   }
 
   int stream_max_bitrate =
       MinPositive(rtp_parameters_.encodings[0].max_bitrate_bps,
                   parameters_.max_bitrate_bps);
+  encoder_config.streams = CreateVideoStreams(
+      clamped_codec, parameters_.options, stream_max_bitrate, stream_count);
+  encoder_config.expect_encode_from_texture = last_frame_info_.is_texture;
 
-  int codec_max_bitrate_kbps;
-  if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
-    stream_max_bitrate = codec_max_bitrate_kbps * 1000;
+  // Conference mode screencast uses 2 temporal layers split at 100kbit.
+  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);
   }
-  encoder_config.max_bitrate_bps = stream_max_bitrate;
-
-  int max_qp = kDefaultQpMax;
-  codec.GetParam(kCodecParamMaxQuantization, &max_qp);
-  int max_framerate =
-      codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
-
-  encoder_config.video_stream_factory =
-      new rtc::RefCountedObject<EncoderStreamFactory>(
-          codec.name, max_qp, max_framerate, is_screencast,
-          parameters_.conference_mode);
+  if (CodecNamesEq(codec.name, kVp9CodecName) && !is_screencast &&
+      encoder_config.streams.size() == 1) {
+    encoder_config.streams[0].temporal_layer_thresholds_bps.resize(
+        GetDefaultVp9TemporalLayers() - 1);
+  }
   return encoder_config;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::ReconfigureEncoder() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
-  RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0u);
+  RTC_DCHECK(!parameters_.encoder_config.streams.empty());
 
   RTC_CHECK(parameters_.codec_settings);
   VideoCodecSettings codec_settings = *parameters_.codec_settings;
 
   webrtc::VideoEncoderConfig encoder_config =
       CreateVideoEncoderConfig(codec_settings.codec);
 
   encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
       codec_settings.codec);
 
   stream_->ReconfigureVideoEncoder(encoder_config.Copy());
 
   encoder_config.encoder_specific_settings = NULL;
 
   parameters_.encoder_config = std::move(encoder_config);
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSend(bool send) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  rtc::CritScope cs(&lock_);
   sending_ = send;
   UpdateSendState();
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::AddOrUpdateSink(
     VideoSinkInterface<webrtc::VideoFrame>* sink,
     const rtc::VideoSinkWants& wants) {
   // TODO(perkj): Actually consider the encoder |wants| and remove
   // WebRtcVideoSendStream::OnLoadUpdate(Load load).
   rtc::CritScope cs(&lock_);
   RTC_DCHECK(!encoder_sink_ || encoder_sink_ == sink);
   encoder_sink_ = sink;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::RemoveSink(
     VideoSinkInterface<webrtc::VideoFrame>* sink) {
   rtc::CritScope cs(&lock_);
   RTC_DCHECK_EQ(encoder_sink_, sink);
   encoder_sink_ = nullptr;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate(Load load) {
   if (worker_thread_ != rtc::Thread::Current()) {
     invoker_.AsyncInvoke<void>(
         RTC_FROM_HERE, worker_thread_,
         rtc::Bind(&WebRtcVideoChannel2::WebRtcVideoSendStream::OnLoadUpdate,
                   this, load));
     return;
   }
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!source_) {
     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 (parameters_.options.is_screencast.value_or(false))
+      return;
 
-  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 (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) {
-    rtc::CritScope cs(&lock_);
-    if (cpu_restricted_counter_ >= kMaxCpuDowngrades) {
-      return;
+    rtc::Optional<int> max_pixel_count;
+    rtc::Optional<int> max_pixel_count_step_up;
+    if (load == kOveruse) {
+      if (cpu_restricted_counter_ >= kMaxCpuDowngrades) {
+        return;
+      }
+      // The input video frame size will have a resolution with less than or
+      // equal to |max_pixel_count| depending on how the source can scale the
+      // input frame size.
+      max_pixel_count = rtc::Optional<int>(
+          (last_frame_info_.height * last_frame_info_.width * 3) / 5);
+      // Increase |number_of_cpu_adapt_changes_| if
+      // sink_wants_.max_pixel_count will be changed since
+      // last time |source_->AddOrUpdateSink| was called. That is, this will
+      // result in a new request for the source to change resolution.
+      if (!sink_wants_.max_pixel_count ||
+          *sink_wants_.max_pixel_count > *max_pixel_count) {
+        ++number_of_cpu_adapt_changes_;
+        ++cpu_restricted_counter_;
+      }
+    } else {
+      RTC_DCHECK(load == kUnderuse);
+      // The input video frame size will have a resolution with "one step up"
+      // pixels than |max_pixel_count_step_up| where "one step up" depends on
+      // how the source can scale the input frame size.
+      max_pixel_count_step_up =
+          rtc::Optional<int>(last_frame_info_.height * last_frame_info_.width);
+      // Increase |number_of_cpu_adapt_changes_| if
+      // sink_wants_.max_pixel_count_step_up will be changed since
+      // last time |source_->AddOrUpdateSink| was called. That is, this will
+      // result in a new request for the source to change resolution.
+      if (sink_wants_.max_pixel_count ||
+          (sink_wants_.max_pixel_count_step_up &&
+           *sink_wants_.max_pixel_count_step_up < *max_pixel_count_step_up)) {
+        ++number_of_cpu_adapt_changes_;
+        --cpu_restricted_counter_;
+      }
     }
-    // The input video frame size will have a resolution with less than or
-    // equal to |max_pixel_count| depending on how the source can scale the
-    // input frame size.
-    max_pixel_count = rtc::Optional<int>(
-        (last_frame_info_.height * last_frame_info_.width * 3) / 5);
-    // Increase |number_of_cpu_adapt_changes_| if
-    // sink_wants_.max_pixel_count will be changed since
-    // last time |source_->AddOrUpdateSink| was called. That is, this will
-    // result in a new request for the source to change resolution.
-    if (!sink_wants_.max_pixel_count ||
-        *sink_wants_.max_pixel_count > *max_pixel_count) {
-      ++number_of_cpu_adapt_changes_;
-      ++cpu_restricted_counter_;
-    }
-  } else {
-    RTC_DCHECK(load == kUnderuse);
-    rtc::CritScope cs(&lock_);
-    // The input video frame size will have a resolution with "one step up"
-    // pixels than |max_pixel_count_step_up| where "one step up" depends on
-    // how the source can scale the input frame size.
-    max_pixel_count_step_up =
-        rtc::Optional<int>(last_frame_info_.height * last_frame_info_.width);
-    // Increase |number_of_cpu_adapt_changes_| if
-    // sink_wants_.max_pixel_count_step_up will be changed since
-    // last time |source_->AddOrUpdateSink| was called. That is, this will
-    // result in a new request for the source to change resolution.
-    if (sink_wants_.max_pixel_count ||
-        (sink_wants_.max_pixel_count_step_up &&
-         *sink_wants_.max_pixel_count_step_up < *max_pixel_count_step_up)) {
-      ++number_of_cpu_adapt_changes_;
-      --cpu_restricted_counter_;
-    }
+    sink_wants_.max_pixel_count = max_pixel_count;
+    sink_wants_.max_pixel_count_step_up = max_pixel_count_step_up;
   }
-  sink_wants_.max_pixel_count = max_pixel_count;
-  sink_wants_.max_pixel_count_step_up = max_pixel_count_step_up;
   // |source_->AddOrUpdateSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   source_->AddOrUpdateSink(this, sink_wants_);
 }
 
 VideoSenderInfo WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo(
     bool log_stats) {
   VideoSenderInfo info;
-  RTC_DCHECK_RUN_ON(&thread_checker_);
-  for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
-    info.add_ssrc(ssrc);
+  webrtc::VideoSendStream::Stats stats;
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  {
+    rtc::CritScope cs(&lock_);
+    for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
+      info.add_ssrc(ssrc);
 
-  if (parameters_.codec_settings)
-    info.codec_name = parameters_.codec_settings->codec.name;
+    if (parameters_.codec_settings)
+      info.codec_name = parameters_.codec_settings->codec.name;
 
-  if (stream_ == NULL)
-    return info;
+    if (stream_ == NULL)
+      return info;
 
-  webrtc::VideoSendStream::Stats stats = stream_->GetStats();
+    stats = stream_->GetStats();
+  }
 
   if (log_stats)
     LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
 
   info.adapt_changes = number_of_cpu_adapt_changes_;
   info.adapt_reason =
       cpu_restricted_counter_ <= 0 ? ADAPTREASON_NONE : ADAPTREASON_CPU;
 
   // Get bandwidth limitation info from stream_->GetStats().
   // Input resolution (output from video_adapter) can be further scaled down or
@@ skipping 40 matching lines @@
     info.fraction_lost =
         static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
         (1 << 8);
   }
 
   return info;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo(
     BandwidthEstimationInfo* bwe_info) {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
+  rtc::CritScope cs(&lock_);
   if (stream_ == NULL) {
     return;
   }
   webrtc::VideoSendStream::Stats stats = stream_->GetStats();
   for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
            stats.substreams.begin();
        it != stats.substreams.end(); ++it) {
     bwe_info->transmit_bitrate += it->second.total_bitrate_bps;
     bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps;
   }
   bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps;
   bwe_info->actual_enc_bitrate += stats.media_bitrate_bps;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
-  RTC_DCHECK_RUN_ON(&thread_checker_);
   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);
 
   webrtc::VideoSendStream::Config config = parameters_.config.Copy();
   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(std::move(config),
                                          parameters_.encoder_config.Copy());
   stream_->SetSource(this);
 
   parameters_.encoder_config.encoder_specific_settings = NULL;
+  pending_encoder_reconfiguration_ = false;
 
   // Call stream_->Start() if necessary conditions are met.
   UpdateSendState();
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
     WebRtcVideoDecoderFactory* external_decoder_factory,
@@ skipping 435 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