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 {
+    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 kMinVideoBitrate = 30;
-const int kStartVideoBitrate = 300;
+const int kMinVideoBitrateKbps = 30;
 
 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;
-}
-
 void* 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 1067 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(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_RUN_ON(&thread_checker_);
 
   // Ignore |options| pointer if |enable| is false.
   bool options_present = enable && options;
   bool source_changing = source_ != source;
   if (source_changing) {
     DisconnectSource();
   }
 
   if (options_present || source_changing) {

[sprang_webrtc, 2016/09/22 13:06:16]

This looks redundant?

[perkj_webrtc, 2016/09/26 12:09:42]

Done.

-    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 options has changed and SetCodec has been called.
+      if (parameters_.options != old_options && stream_) {
+        ReconfigureEncoder();
       }
     }
 
     if (source_changing) {
-      if (source == nullptr && encoder_sink_ != nullptr) {
+      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(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   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(!parameters_.encoder_config.streams.empty());
+  RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0u);
 
   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::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;
-    }
+  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;
+  }
 
-    // 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_|
+  // 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();
+  }
 
   // |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;
   }
 
-  rtc::CritScope cs(&lock_);
-  if (new_parameters.encodings[0].max_bitrate_bps !=
-      rtp_parameters_.encodings[0].max_bitrate_bps) {
-    pending_encoder_reconfiguration_ = true;
-  }
+  bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps !=
+                             rtp_parameters_.encodings[0].max_bitrate_bps;
   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::CritScope cs(&lock_);
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   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.
-  size_t stream_count = parameters_.config.rtp.ssrcs.size();
+  encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size();
   if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) {
-    stream_count = 1;
+    encoder_config.number_of_streams = 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;
 
-  // 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();
+  int codec_max_bitrate_kbps;
+  if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) {
+    stream_max_bitrate = codec_max_bitrate_kbps * 1000;
+  }
+  encoder_config.max_bitrate_bps = stream_max_bitrate;
 
-    // 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);
-  }
-  if (CodecNamesEq(codec.name, kVp9CodecName) && !is_screencast &&
-      encoder_config.streams.size() == 1) {
-    encoder_config.streams[0].temporal_layer_thresholds_bps.resize(
-        GetDefaultVp9TemporalLayers() - 1);
-  }
+  int max_qp = kDefaultQpMax;
+  codec.GetParam(kCodecParamMaxQuantization, &max_qp);
+  int max_framerate =
+      codec.framerate != 0 ? codec.framerate : kDefaultVideoMaxFramerate;
+
+  encoder_config.encoder_stream_factory =
+      new rtc::RefCountedObject<EncoderStreamFactory>(
+          codec.name, max_qp, max_framerate, is_screencast,
+          parameters_.conference_mode);
   return encoder_config;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::ReconfigureEncoder() {
-  RTC_DCHECK(!parameters_.encoder_config.streams.empty());
+  RTC_DCHECK_RUN_ON(&thread_checker_);
+  RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0u);
 
   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::CritScope cs(&lock_);
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   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(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   if (!source_) {
     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_);
-    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))
+    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_;
-      }
     }
-    sink_wants_.max_pixel_count = max_pixel_count;
-    sink_wants_.max_pixel_count_step_up = max_pixel_count_step_up;
+    // 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;
   // |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;
   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);
+  RTC_DCHECK_RUN_ON(&thread_checker_);
+  for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
+    info.add_ssrc(ssrc);
 
-    if (parameters_.codec_settings)
-      info.codec_name = parameters_.codec_settings->codec.name;
-    for (size_t i = 0; i < parameters_.encoder_config.streams.size(); ++i) {
-      if (i == parameters_.encoder_config.streams.size() - 1) {
-        info.preferred_bitrate +=
-            parameters_.encoder_config.streams[i].max_bitrate_bps;
-      } else {
-        info.preferred_bitrate +=
-            parameters_.encoder_config.streams[i].target_bitrate_bps;
-      }
-    }
+  if (parameters_.codec_settings)
+    info.codec_name = parameters_.codec_settings->codec.name;
 
-    if (stream_ == NULL)
-      return info;
+  if (stream_ == NULL)
+    return info;
 
-    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
   // higher video layer(s) can be dropped due to bitrate constraints.
   // Note, adapt_changes only include changes from the video_adapter.
   if (stats.bw_limited_resolution)
     info.adapt_reason |= ADAPTREASON_BANDWIDTH;
 
   info.encoder_implementation_name = stats.encoder_implementation_name;
   info.ssrc_groups = ssrc_groups_;
   info.framerate_input = stats.input_frame_rate;
   info.framerate_sent = stats.encode_frame_rate;
   info.avg_encode_ms = stats.avg_encode_time_ms;
   info.encode_usage_percent = stats.encode_usage_percent;
 
   info.nominal_bitrate = stats.media_bitrate_bps;
+  info.preferred_bitrate = stats.preffered_media_bitrate_bps;
 
   info.send_frame_width = 0;
   info.send_frame_height = 0;
   for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it =
            stats.substreams.begin();
        it != stats.substreams.end(); ++it) {
     // TODO(pbos): Wire up additional stats, such as padding bytes.
     webrtc::VideoSendStream::StreamStats stream_stats = it->second;
     info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes +
                        stream_stats.rtp_stats.transmitted.header_bytes +
@@ skipping 16 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::CritScope cs(&lock_);
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   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