Initialize VideoEncoder objects asynchronously.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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 74 matching lines @@
   ss << ", rtx: " << rtx.ToString();
   ss << ", c_name: " << c_name;
   ss << '}';
   return ss.str();
 }
 
 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"
                                                                       : "off");
   ss << '}';
   return ss.str();
 }
 
 namespace internal {
 VideoSendStream::VideoSendStream(
     int num_cpu_cores,
     ProcessThread* module_process_thread,
     CallStats* call_stats,
     CongestionController* congestion_controller,
     BitrateAllocator* bitrate_allocator,
     const VideoSendStream::Config& config,
     const VideoEncoderConfig& encoder_config,
     const std::map<uint32_t, RtpState>& suspended_ssrcs)
     : stats_proxy_(Clock::GetRealTimeClock(),
                    config,
                    encoder_config.content_type),
       transport_adapter_(config.send_transport),
       encoded_frame_proxy_(config.post_encode_callback),
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
       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());
 
   // Set up Call-wide sequence numbers, if configured for this send stream.
   TransportFeedbackObserver* transport_feedback_observer = nullptr;
   for (const RtpExtension& extension : config.rtp.extensions) {
     if (extension.name == RtpExtension::kTransportSequenceNumber) {
       transport_feedback_observer =
           congestion_controller_->GetTransportFeedbackObserver();
       break;
@@ skipping 58 matching lines @@
                                   config_.rtp.fec.red_payload_type,
                                   config_.rtp.fec.ulpfec_payload_type);
   vie_encoder_->SetProtectionMethod(enable_protection_nack,
                                     enable_protection_fec);
 
   ConfigureSsrcs();
 
   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_);
 
   if (config_.post_encode_callback)
     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());
 
   vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
   vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
   vie_channel_->RegisterRtcpPacketTypeCounterObserver(&stats_proxy_);
   vie_channel_->RegisterSendBitrateObserver(&stats_proxy_);
   vie_channel_->RegisterSendFrameCountObserver(&stats_proxy_);
 }
 
 VideoSendStream::~VideoSendStream() {
   LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
   vie_channel_->RegisterSendFrameCountObserver(nullptr);
   vie_channel_->RegisterSendBitrateObserver(nullptr);
   vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr);
   vie_channel_->RegisterSendChannelRtpStatisticsCallback(nullptr);
   vie_channel_->RegisterSendChannelRtcpStatisticsCallback(nullptr);
 
   // Remove capture input (thread) so that it's not running after the current
   // 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());
 
   // Remove the feedback, stop all encoding threads and processing. This must be
   // done before deleting the channel.
   congestion_controller_->RemoveEncoder(vie_encoder_.get());
   encoder_feedback_->RemoveEncoder(vie_encoder_.get());
   vie_encoder_->StopThreadsAndRemoveSharedMembers();
 
@@ skipping 17 matching lines @@
   vie_channel_->StartReceive();
 }
 
 void VideoSendStream::Stop() {
   // TODO(pbos): Make sure the encoder stops here.
   vie_channel_->StopSend();
   vie_channel_->StopReceive();
   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();
   const std::vector<VideoStream>& streams = config.streams;
   RTC_DCHECK(!streams.empty());
   RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
   if (config_.encoder_settings.payload_name == "VP8") {
@@ skipping 113 matching lines @@
                                  static_cast<unsigned int>(streams[i].max_qp));
   }
 
   // Set to zero to not update the bitrate controller from ViEEncoder, as
   // the bitrate controller is already set from Call.
   video_codec.startBitrate = 0;
 
   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) {
   return vie_channel_->ReceivedRTCPPacket(packet, length) == 0;
 }
 
 VideoSendStream::Stats VideoSendStream::GetStats() {
   return stats_proxy_.GetStats();
 }
 
@@ skipping 76 matching lines @@
                                           &jitter, &rtt_ms) == 0) {
     return rtt_ms;
   }
   return -1;
 }
 
 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.
     video_codec.maxBitrate =
         (video_codec.width * video_codec.height * video_codec.maxFramerate) /
         1000;
   }
 
   if (video_codec.minBitrate < kEncoderMinBitrate)
     video_codec.minBitrate = kEncoderMinBitrate;
   if (video_codec.maxBitrate < kEncoderMinBitrate)
     video_codec.maxBitrate = kEncoderMinBitrate;
 
   // 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.)
   std::vector<uint32_t> used_ssrcs = config_.rtp.ssrcs;
   used_ssrcs.resize(static_cast<size_t>(video_codec.numberOfSimulcastStreams));
   vie_encoder_->SetSsrcs(used_ssrcs);
 
   // 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
 }  // namespace webrtc