Measure encoding time on encode callbacks.

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.
  */
 
 #include "webrtc/video/video_send_stream.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call/congestion_controller.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/pacing/packet_router.h"
+#include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/encoder_state_feedback.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/video_capture_input.h"
 #include "webrtc/video/vie_channel.h"
 #include "webrtc/video/vie_encoder.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 
@@ skipping 65 matching lines @@
   ss << ", local_renderer: " << (local_renderer != nullptr ? "(VideoRenderer)"
                                                          : "nullptr");
   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 {
+
+CpuOveruseOptions GetCpuOveruseOptions(bool full_overuse_time) {
+  CpuOveruseOptions options;
+  if (full_overuse_time) {
+    options.low_encode_usage_threshold_percent = 100;
+    options.high_encode_usage_threshold_percent = 120;
+  }
+  return options;
+}
+}  // namespace
+
 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),
+      overuse_detector_(
+          Clock::GetRealTimeClock(),
+          GetCpuOveruseOptions(config.encoder_settings.full_overuse_time),
+          this,
+          &stats_proxy_),
       encoder_feedback_(new EncoderStateFeedback()),
       use_config_bitrate_(true) {
   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;
     }
   }
 
   const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
 
-  vie_encoder_.reset(new ViEEncoder(
-      num_cpu_cores, module_process_thread_, &stats_proxy_,
-      config.pre_encode_callback, congestion_controller_->pacer(),
-      bitrate_allocator));
+  vie_encoder_.reset(new ViEEncoder(num_cpu_cores,
+                                    module_process_thread_,
+                                    &stats_proxy_,
+                                    config.pre_encode_callback,
+                                    &overuse_detector_,
+                                    congestion_controller_->pacer(),
+                                    bitrate_allocator));
   RTC_CHECK(vie_encoder_->Init());
 
   vie_channel_.reset(new ViEChannel(
       num_cpu_cores, config.send_transport, module_process_thread_,
       encoder_feedback_->GetRtcpIntraFrameObserver(),
       congestion_controller_->GetBitrateController()->
           CreateRtcpBandwidthObserver(),
       transport_feedback_observer,
       congestion_controller_->GetRemoteBitrateEstimator(false),
       call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(),
@@ skipping 39 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));
+      vie_encoder_.get(), config_.local_renderer, &stats_proxy_,
+      &overuse_detector_, config_.encoding_time_observer));
 
   // 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,
@@ skipping 11 matching lines @@
     vie_encoder_->SuspendBelowMinBitrate();
 
   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_);
+
+  module_process_thread_->RegisterModule(&overuse_detector_);
 }
 
 VideoSendStream::~VideoSendStream() {
   LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
+  module_process_thread_->DeRegisterModule(&overuse_detector_);
   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();
 
@@ skipping 318 matching lines @@
   vie_encoder_->SetSsrcs(used_ssrcs);
 
   // Restart the media flow
   vie_encoder_->Restart();
 
   return true;
 }
 
 }  // namespace internal
 }  // namespace webrtc