Reland of Make the new jitter buffer the default jitter buffer.

webrtc/video/receive_statistics_proxy.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/receive_statistics_proxy.h"
 
+#include <algorithm>
 #include <cmath>
+#include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
 // Periodic time interval for processing samples for |freq_offset_counter_|.
 const int64_t kFreqOffsetProcessIntervalMs = 40000;
 
 // Configuration for bad call detection.
 const int kBadCallMinRequiredSamples = 10;
 const int kMinSampleLengthMs = 990;
 const int kNumMeasurements = 10;
 const int kNumMeasurementsVariance = kNumMeasurements * 1.5;
 const float kBadFraction = 0.8f;
 // For fps:
 // Low means low enough to be bad, high means high enough to be good
 const int kLowFpsThreshold = 12;
 const int kHighFpsThreshold = 14;
 // For qp and fps variance:
 // Low means low enough to be good, high means high enough to be bad
 const int kLowQpThresholdVp8 = 60;
 const int kHighQpThresholdVp8 = 70;
 const int kLowVarianceThreshold = 1;
 const int kHighVarianceThreshold = 2;
+
+// How large window we use to calculate the framerate/bitrate.
+const int kRateStatisticsWindowSizeMs = 1000;
 }  // namespace
 
 ReceiveStatisticsProxy::ReceiveStatisticsProxy(
     const VideoReceiveStream::Config* config,
     Clock* clock)
     : clock_(clock),
       config_(*config),
       start_ms_(clock->TimeInMilliseconds()),
       last_sample_time_(clock->TimeInMilliseconds()),
       fps_threshold_(kLowFpsThreshold,
                      kHighFpsThreshold,
                      kBadFraction,
                      kNumMeasurements),
       qp_threshold_(kLowQpThresholdVp8,
                     kHighQpThresholdVp8,
                     kBadFraction,
                     kNumMeasurements),
       variance_threshold_(kLowVarianceThreshold,
                           kHighVarianceThreshold,
                           kBadFraction,
                           kNumMeasurementsVariance),
       num_bad_states_(0),
       num_certain_states_(0),
       // 1000ms window, scale 1000 for ms to s.
       decode_fps_estimator_(1000, 1000),
       renders_fps_estimator_(1000, 1000),
       render_fps_tracker_(100, 10u),
       render_pixel_tracker_(100, 10u),
       freq_offset_counter_(clock, nullptr, kFreqOffsetProcessIntervalMs),
-      first_report_block_time_ms_(-1) {
+      first_report_block_time_ms_(-1),
+      avg_rtt_ms_(0),
+      frame_window_accumulated_bytes_(0) {
   stats_.ssrc = config_.rtp.remote_ssrc;
   for (auto it : config_.rtp.rtx)
     rtx_stats_[it.second.ssrc] = StreamDataCounters();
 }
 
 ReceiveStatisticsProxy::~ReceiveStatisticsProxy() {
   UpdateHistograms();
 }
 
 void ReceiveStatisticsProxy::UpdateHistograms() {
@@ skipping 31 matching lines @@
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.AVSyncOffsetInMs", sync_offset_ms);
   }
   AggregatedStats freq_offset_stats = freq_offset_counter_.GetStats();
   if (freq_offset_stats.num_samples > 0) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.RtpToNtpFreqOffsetInKhz",
                                freq_offset_stats.average);
     LOG(LS_INFO) << "WebRTC.Video.RtpToNtpFreqOffsetInKhz, "
                  << freq_offset_stats.ToString();
   }
 
+  if (stats_.frame_counts.key_frames > 0 ||
+      stats_.frame_counts.delta_frames > 0) {
+    float num_key_frames = stats_.frame_counts.key_frames;
+    float num_total_frames =
+        stats_.frame_counts.key_frames + stats_.frame_counts.delta_frames;
+    int key_frames_permille =
+        (num_key_frames * 1000.0f / num_total_frames + 0.5f);
+    RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.KeyFramesReceivedInPermille",
+                              key_frames_permille);
+  }
+
   int qp = qp_counters_.vp8.Avg(kMinRequiredSamples);
   if (qp != -1)
     RTC_HISTOGRAM_COUNTS_200("WebRTC.Video.Decoded.Vp8.Qp", qp);
 
   // TODO(asapersson): DecoderTiming() is call periodically (each 1000ms) and
   // not per frame. Change decode time to include every frame.
   const int kMinRequiredDecodeSamples = 5;
   int decode_ms = decode_time_counter_.Avg(kMinRequiredDecodeSamples);
   if (decode_ms != -1)
     RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DecodeTimeInMs", decode_ms);
 
-  if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") !=
-        "Enabled") {
-    int jb_delay_ms =
-        jitter_buffer_delay_counter_.Avg(kMinRequiredDecodeSamples);
-    if (jb_delay_ms != -1) {
-      RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs",
-                                 jb_delay_ms);
-    }
+  int jb_delay_ms = jitter_buffer_delay_counter_.Avg(kMinRequiredDecodeSamples);
+  if (jb_delay_ms != -1) {
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs",
+                               jb_delay_ms);
   }
+
   int target_delay_ms = target_delay_counter_.Avg(kMinRequiredDecodeSamples);
   if (target_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.TargetDelayInMs", target_delay_ms);
   }
   int current_delay_ms = current_delay_counter_.Avg(kMinRequiredDecodeSamples);
   if (current_delay_ms != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.CurrentDelayInMs",
                                current_delay_ms);
   }
   int delay_ms = delay_counter_.Avg(kMinRequiredDecodeSamples);
@@ skipping 136 matching lines @@
   qp_sample_.Reset();
 
   if (fps_threshold_.IsHigh() || variance_threshold_.IsHigh() ||
       qp_threshold_.IsHigh()) {
     if (any_bad)
       ++num_bad_states_;
     ++num_certain_states_;
   }
 }
 
+void ReceiveStatisticsProxy::UpdateFrameAndBitrate(int64_t now_ms) const {
+  int64_t old_frames_ms = now_ms - kRateStatisticsWindowSizeMs;
+  while (!frame_window_.empty() &&
+         frame_window_.begin()->first < old_frames_ms) {
+    frame_window_accumulated_bytes_ -= frame_window_.begin()->second;
+    frame_window_.erase(frame_window_.begin());
+  }
+
+  size_t framerate =
+      (frame_window_.size() * 1000 + 500) / kRateStatisticsWindowSizeMs;
+  size_t bitrate_bps =
+      frame_window_accumulated_bytes_ * 8000 / kRateStatisticsWindowSizeMs;
+  stats_.network_frame_rate = static_cast<int>(framerate);
+  stats_.total_bitrate_bps = static_cast<int>(bitrate_bps);
+}
+
 VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
   rtc::CritScope lock(&crit_);
+  UpdateFrameAndBitrate(clock_->TimeInMilliseconds());
   return stats_;
 }
 
 void ReceiveStatisticsProxy::OnIncomingPayloadType(int payload_type) {
   rtc::CritScope lock(&crit_);
   stats_.current_payload_type = payload_type;
 }
 
 void ReceiveStatisticsProxy::OnDecoderImplementationName(
     const char* implementation_name) {
   rtc::CritScope lock(&crit_);
   stats_.decoder_implementation_name = implementation_name;
 }
 void ReceiveStatisticsProxy::OnIncomingRate(unsigned int framerate,
                                             unsigned int bitrate_bps) {
   rtc::CritScope lock(&crit_);
   if (stats_.rtp_stats.first_packet_time_ms != -1)
     QualitySample();
-  stats_.network_frame_rate = framerate;
-  stats_.total_bitrate_bps = bitrate_bps;
 }
 
-void ReceiveStatisticsProxy::OnDecoderTiming(int decode_ms,
-                                             int max_decode_ms,
-                                             int current_delay_ms,
-                                             int target_delay_ms,
-                                             int jitter_buffer_ms,
-                                             int min_playout_delay_ms,
-                                             int render_delay_ms,
-                                             int64_t rtt_ms) {
+void ReceiveStatisticsProxy::OnFrameBufferTimingsUpdated(
+    int decode_ms,
+    int max_decode_ms,
+    int current_delay_ms,
+    int target_delay_ms,
+    int jitter_buffer_ms,
+    int min_playout_delay_ms,
+    int render_delay_ms) {
   rtc::CritScope lock(&crit_);
   stats_.decode_ms = decode_ms;
   stats_.max_decode_ms = max_decode_ms;
   stats_.current_delay_ms = current_delay_ms;
   stats_.target_delay_ms = target_delay_ms;
   stats_.jitter_buffer_ms = jitter_buffer_ms;
   stats_.min_playout_delay_ms = min_playout_delay_ms;
   stats_.render_delay_ms = render_delay_ms;
   decode_time_counter_.Add(decode_ms);
   jitter_buffer_delay_counter_.Add(jitter_buffer_ms);
   target_delay_counter_.Add(target_delay_ms);
   current_delay_counter_.Add(current_delay_ms);
   // Network delay (rtt/2) + target_delay_ms (jitter delay + decode time +
   // render delay).
-  delay_counter_.Add(target_delay_ms + rtt_ms / 2);
+  delay_counter_.Add(target_delay_ms + avg_rtt_ms_ / 2);
 }
 
 void ReceiveStatisticsProxy::RtcpPacketTypesCounterUpdated(
     uint32_t ssrc,
     const RtcpPacketTypeCounter& packet_counter) {
   rtc::CritScope lock(&crit_);
   if (stats_.ssrc != ssrc)
     return;
   stats_.rtcp_packet_type_counts = packet_counter;
 }
@@ skipping 84 matching lines @@
   if (estimated_freq_khz < kMaxFreqKhz && estimated_freq_khz > 0.0)
     offset_khz = static_cast<int>(std::fabs(estimated_freq_khz - 90.0) + 0.5);
 
   freq_offset_counter_.Add(offset_khz);
 }
 
 void ReceiveStatisticsProxy::OnReceiveRatesUpdated(uint32_t bitRate,
                                                    uint32_t frameRate) {
 }
 
+void ReceiveStatisticsProxy::OnCompleteFrame(bool is_keyframe,
+                                             size_t size_bytes) {
+  rtc::CritScope lock(&crit_);
+  if (is_keyframe)
+    ++stats_.frame_counts.key_frames;
+  else
+    ++stats_.frame_counts.delta_frames;
+
+  int64_t now_ms = clock_->TimeInMilliseconds();
+  frame_window_accumulated_bytes_ += size_bytes;
+  frame_window_.insert(std::make_pair(now_ms, size_bytes));
+  UpdateFrameAndBitrate(now_ms);
+}
+
 void ReceiveStatisticsProxy::OnFrameCountsUpdated(
     const FrameCounts& frame_counts) {
   rtc::CritScope lock(&crit_);
   stats_.frame_counts = frame_counts;
 }
 
 void ReceiveStatisticsProxy::OnDiscardedPacketsUpdated(int discarded_packets) {
   rtc::CritScope lock(&crit_);
   stats_.discarded_packets = discarded_packets;
 }
@@ skipping 21 matching lines @@
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return static_cast<int>(sum / num_samples);
 }
 
 void ReceiveStatisticsProxy::SampleCounter::Reset() {
   num_samples = 0;
   sum = 0;
 }
 
+void ReceiveStatisticsProxy::OnRttUpdate(int64_t avg_rtt_ms,
+                                         int64_t max_rtt_ms) {
+  rtc::CritScope lock(&crit_);
+  avg_rtt_ms_ = avg_rtt_ms;
+}
+
 }  // namespace webrtc