Measure encoding time on encode callbacks.

webrtc/video/vie_encoder.cc

 /*
  *  Copyright (c) 2012 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/vie_encoder.h"
 
 #include <assert.h>
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call/bitrate_allocator.h"
 #include "webrtc/common_video/include/video_image.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/frame_callback.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
-#include "webrtc/modules/video_coding/encoded_frame.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
+#include "webrtc/video/overuse_frame_detector.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/send_statistics_proxy.h"
+#include "webrtc/video_frame.h"
 
 namespace webrtc {
 
 // Margin on when we pause the encoder when the pacing buffer overflows relative
 // to the configured buffer delay.
 static const float kEncoderPausePacerMargin = 2.0f;
 
 // Don't stop the encoder unless the delay is above this configured value.
 static const int kMinPacingDelayMs = 200;
 
@@ skipping 54 matching lines @@
     owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt);
   }
  private:
   ViEEncoder* owner_;
 };
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        ProcessThread* module_process_thread,
                        SendStatisticsProxy* stats_proxy,
                        I420FrameCallback* pre_encode_callback,
+                       OveruseFrameDetector* overuse_detector,
                        PacedSender* pacer,
                        BitrateAllocator* bitrate_allocator)
     : number_of_cores_(number_of_cores),
       vp_(VideoProcessing::Create()),
       qm_callback_(new QMVideoSettingsCallback(vp_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      this,
                                      qm_callback_.get())),
       send_payload_router_(NULL),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
+      overuse_detector_(overuse_detector),
       pacer_(pacer),
       bitrate_allocator_(bitrate_allocator),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
@@ skipping 323 matching lines @@
   RTC_DCHECK(send_payload_router_ != NULL);
 
   {
     rtc::CritScope lock(&data_cs_);
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
   }
 
   if (stats_proxy_ != NULL)
     stats_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
 
-  return send_payload_router_->RoutePayload(
-             encoded_image._frameType, payload_type, encoded_image._timeStamp,
-             encoded_image.capture_time_ms_, encoded_image._buffer,
-             encoded_image._length, fragmentation_header, rtp_video_hdr)
-             ? 0
-             : -1;
+  bool success = send_payload_router_->RoutePayload(
+      encoded_image._frameType, payload_type, encoded_image._timeStamp,
+      encoded_image.capture_time_ms_, encoded_image._buffer,
+      encoded_image._length, fragmentation_header, rtp_video_hdr);
+  overuse_detector_->FrameSent(encoded_image._timeStamp);
+  return success ? 0 : -1;
 }
 
 void ViEEncoder::OnEncoderImplementationName(
     const char* implementation_name) {
   if (stats_proxy_)
     stats_proxy_->OnEncoderImplementationName(implementation_name);
 }
 
 int32_t ViEEncoder::SendStatistics(const uint32_t bit_rate,
                                    const uint32_t frame_rate) {
@@ skipping 142 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc