Initialize VideoEncoder objects asynchronously.

webrtc/video/video_send_stream.cc

Index: webrtc/video/video_send_stream.cc
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 656d5517941754df85a99a073d9634718a46c365..419c960910fad60dde1e4eef6c9b86defc7a6b05 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -92,13 +92,12 @@ std::string VideoSendStream::Config::ToString() const {
   std::stringstream ss;
   ss << "{encoder_settings: " << encoder_settings.ToString();
   ss << ", rtp: " << rtp.ToString();
-  ss << ", pre_encode_callback: "
-     << (pre_encode_callback != nullptr ? "(I420FrameCallback)" : "nullptr");
-  ss << ", post_encode_callback: " << (post_encode_callback != nullptr
-                                           ? "(EncodedFrameObserver)"
-                                           : "nullptr");
-  ss << ", local_renderer: " << (local_renderer != nullptr ? "(VideoRenderer)"
-                                                         : "nullptr");
+  if (pre_encode_callback)
+    ss << ", pre_encode_effects: (I420FrameCallback)";
+  if (post_encode_callback)
+    ss << ", post_encode_callback: (EncodedFrameObserver)";
+  if (local_renderer)
+    ss << ", local_renderer: (VideoRenderer)";
   ss << ", render_delay_ms: " << render_delay_ms;
   ss << ", target_delay_ms: " << target_delay_ms;
   ss << ", suspend_below_min_bitrate: " << (suspend_below_min_bitrate ? "on"
@@ -127,8 +126,7 @@ VideoSendStream::VideoSendStream(
       module_process_thread_(module_process_thread),
       call_stats_(call_stats),
       congestion_controller_(congestion_controller),
-      encoder_feedback_(new EncoderStateFeedback()),
-      use_config_bitrate_(true) {
+      encoder_feedback_(new EncoderStateFeedback()) {
   LOG(LS_INFO) << "VideoSendStream: " << config_.ToString();
   RTC_DCHECK(!config_.rtp.ssrcs.empty());
 
@@ -207,22 +205,14 @@ VideoSendStream::VideoSendStream(
   vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str());
 
   input_.reset(new internal::VideoCaptureInput(
-      module_process_thread_, vie_encoder_.get(), config_.local_renderer,
-      &stats_proxy_, this, config_.encoding_time_observer));
+      module_process_thread_, vie_encoder_.get(), vie_encoder_->vcm(), this,
+      config_, &stats_proxy_, this));
 
   // 28 to match packet overhead in ModuleRtpRtcpImpl.
   RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28));
   vie_channel_->SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
 
-  RTC_DCHECK(config.encoder_settings.encoder != nullptr);
-  RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
-  RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
-  RTC_CHECK_EQ(0, vie_encoder_->RegisterExternalEncoder(
-                      config.encoder_settings.encoder,
-                      config.encoder_settings.payload_type,
-                      config.encoder_settings.internal_source));
-
-  RTC_CHECK(ReconfigureVideoEncoder(encoder_config));
+  ReconfigureVideoEncoder(encoder_config);
 
   vie_channel_->RegisterSendSideDelayObserver(&stats_proxy_);
 
@@ -230,7 +220,7 @@ VideoSendStream::VideoSendStream(
     vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
 
   if (config_.suspend_below_min_bitrate)
-    vie_encoder_->SuspendBelowMinBitrate();
+    bitrate_allocator->EnforceMinBitrate(false);
 
   congestion_controller_->AddEncoder(vie_encoder_.get());
   encoder_feedback_->AddEncoder(ssrcs, vie_encoder_.get());
@@ -254,9 +244,6 @@ VideoSendStream::~VideoSendStream() {
   // channel is deleted.
   input_.reset();
 
-  vie_encoder_->DeRegisterExternalEncoder(
-      config_.encoder_settings.payload_type);
-
   call_stats_->DeregisterStatsObserver(vie_channel_->GetStatsObserver());
   congestion_controller_->SetChannelRembStatus(false, false,
                                                vie_channel_->rtp_rtcp());
@@ -294,7 +281,7 @@ void VideoSendStream::Stop() {
   transport_adapter_.Disable();
 }
 
-bool VideoSendStream::ReconfigureVideoEncoder(
+void VideoSendStream::ReconfigureVideoEncoder(
     const VideoEncoderConfig& config) {
   TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder");
   LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString();
@@ -428,23 +415,12 @@ bool VideoSendStream::ReconfigureVideoEncoder(
   RTC_DCHECK_GT(streams[0].max_framerate, 0);
   video_codec.maxFramerate = streams[0].max_framerate;
 
-  if (!SetSendCodec(video_codec))
-    return false;
-
-  // Clear stats for disabled layers.
-  for (size_t i = video_codec.numberOfSimulcastStreams;
-       i < config_.rtp.ssrcs.size(); ++i) {
-    stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
-  }
-
-  stats_proxy_.SetContentType(config.content_type);
+  input_->TriggerSetSendCodec(video_codec);
 
   RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
   vie_encoder_->SetMinTransmitBitrate(config.min_transmit_bitrate_bps / 1000);
 
   encoder_config_ = config;
-  use_config_bitrate_ = false;
-  return true;
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
@@ -541,7 +517,7 @@ int VideoSendStream::GetPaddingNeededBps() const {
   return vie_encoder_->GetPaddingNeededBps();
 }
 
-bool VideoSendStream::SetSendCodec(VideoCodec video_codec) {
+void VideoSendStream::SetSendCodec(VideoCodec video_codec) {
   static const int kEncoderMinBitrate = 30;
   if (video_codec.maxBitrate == 0) {
     // Unset max bitrate -> cap to one bit per pixel.
@@ -558,15 +534,8 @@ bool VideoSendStream::SetSendCodec(VideoCodec video_codec) {
   // Stop the media flow while reconfiguring.
   vie_encoder_->Pause();
 
-  if (vie_encoder_->SetEncoder(video_codec) != 0) {
-    LOG(LS_ERROR) << "Failed to set encoder.";
-    return false;
-  }
-
-  if (vie_channel_->SetSendCodec(video_codec, false) != 0) {
-    LOG(LS_ERROR) << "Failed to set send codec.";
-    return false;
-  }
+  vie_encoder_->SetEncoder(video_codec);
+  vie_channel_->SetSendCodec(video_codec);
 
   // Not all configured SSRCs have to be utilized (simulcast senders don't have
   // to send on all SSRCs at once etc.)
@@ -576,8 +545,17 @@ bool VideoSendStream::SetSendCodec(VideoCodec video_codec) {
 
   // Restart the media flow
   vie_encoder_->Restart();
+  // Clear stats for disabled layers.
+  for (size_t i = video_codec.numberOfSimulcastStreams;
+       i < config_.rtp.ssrcs.size(); ++i) {
+    stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
+  }
 
-  return true;
+  VideoEncoderConfig::ContentType content_type =
+      video_codec.mode == kRealtimeVideo
+          ? VideoEncoderConfig::ContentType::kRealtimeVideo
+          : VideoEncoderConfig::ContentType::kScreen;
+  stats_proxy_.SetContentType(content_type);
 }
 
 }  // namespace internal