Add a rate tracker that tracks rate over a given interval split up into buckets that accumulate uni…

webrtc/video/send_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/send_statistics_proxy.h"
 
 #include <algorithm>
 #include <map>
 
 #include "webrtc/base/checks.h"
 
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
 
 namespace webrtc {
 
 const int SendStatisticsProxy::kStatsTimeoutMs = 5000;
+const size_t SendStatisticsProxy::kFrameRateTrackerInterval =
+    kStatsTimeoutMs / 1000;
 
 SendStatisticsProxy::SendStatisticsProxy(Clock* clock,
                                          const VideoSendStream::Config& config)
     : clock_(clock),
       config_(config),
+      input_frame_rate_tracker_(kFrameRateTrackerInterval),
+      input_frame_rate_tracker_total_(kFrameRateTrackerInterval),
+      sent_frame_rate_tracker_total_(kFrameRateTrackerInterval),
       last_sent_frame_timestamp_(0),
       max_sent_width_per_timestamp_(0),
       max_sent_height_per_timestamp_(0) {
 }
 
 SendStatisticsProxy::~SendStatisticsProxy() {
   UpdateHistograms();
 }
 
 void SendStatisticsProxy::UpdateHistograms() {
   int input_fps =
-      static_cast<int>(input_frame_rate_tracker_total_.units_second());
+      static_cast<int>(input_frame_rate_tracker_total_.ComputeCurrentRate(
+          kFrameRateTrackerInterval * 1000u));

[åsapersson, 2015/08/28 08:12:47]

input_fps and sent_fps below are an average over the call (updated once when a
stream is destructed). These two stats are using an average since last
read/start.

[pbos-webrtc, 2015/08/28 12:47:55]

Can you add support for a ComputeTotalRate() or something equivalent which'd
replace our need for units_second() in RateTracker? (We only pick the rate once,
so that's what we're using it for.)

[tpsiaki, 2015/09/01 20:59:17]

Done.

   if (input_fps > 0)
     RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.InputFramesPerSecond", input_fps);
   int sent_fps =
-      static_cast<int>(sent_frame_rate_tracker_total_.units_second());
+      static_cast<int>(sent_frame_rate_tracker_total_.ComputeCurrentRate(
+          kFrameRateTrackerInterval * 1000u));
   if (sent_fps > 0)
     RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.SentFramesPerSecond", sent_fps);
 
   const int kMinRequiredSamples = 200;
   int in_width = input_width_counter_.Avg(kMinRequiredSamples);
   int in_height = input_height_counter_.Avg(kMinRequiredSamples);
   if (in_width != -1) {
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InputWidthInPixels", in_width);
     RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.InputHeightInPixels", in_height);
   }
@@ skipping 26 matching lines @@
 
 void SendStatisticsProxy::SuspendChange(int video_channel, bool is_suspended) {
   rtc::CritScope lock(&crit_);
   stats_.suspended = is_suspended;
 }
 
 VideoSendStream::Stats SendStatisticsProxy::GetStats() {
   rtc::CritScope lock(&crit_);
   PurgeOldStats();
   stats_.input_frame_rate =
-      static_cast<int>(input_frame_rate_tracker_.units_second());
+      static_cast<int>(input_frame_rate_tracker_.ComputeCurrentRate(
+          kFrameRateTrackerInterval * 1000u));
   return stats_;
 }
 
 void SendStatisticsProxy::PurgeOldStats() {
   int64_t old_stats_ms = clock_->TimeInMilliseconds() - kStatsTimeoutMs;
   for (std::map<uint32_t, VideoSendStream::StreamStats>::iterator it =
            stats_.substreams.begin();
        it != stats_.substreams.end(); ++it) {
     uint32_t ssrc = it->first;
     if (update_times_[ssrc].resolution_update_ms <= old_stats_ms) {
@@ skipping 57 matching lines @@
 
   stats->width = encoded_image._encodedWidth;
   stats->height = encoded_image._encodedHeight;
   update_times_[ssrc].resolution_update_ms = clock_->TimeInMilliseconds();
 
   // TODO(asapersson): This is incorrect if simulcast layers are encoded on
   // different threads and there is no guarantee that one frame of all layers
   // are encoded before the next start.
   if (last_sent_frame_timestamp_ > 0 &&
       encoded_image._timeStamp != last_sent_frame_timestamp_) {
-    sent_frame_rate_tracker_total_.Update(1);
+    sent_frame_rate_tracker_total_.AddSamples(1);
     sent_width_counter_.Add(max_sent_width_per_timestamp_);
     sent_height_counter_.Add(max_sent_height_per_timestamp_);
     max_sent_width_per_timestamp_ = 0;
     max_sent_height_per_timestamp_ = 0;
   }
   last_sent_frame_timestamp_ = encoded_image._timeStamp;
   max_sent_width_per_timestamp_ =
       std::max(max_sent_width_per_timestamp_,
                static_cast<int>(encoded_image._encodedWidth));
   max_sent_height_per_timestamp_ =
       std::max(max_sent_height_per_timestamp_,
                static_cast<int>(encoded_image._encodedHeight));
 }
 
 void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
   rtc::CritScope lock(&crit_);
-  input_frame_rate_tracker_.Update(1);
-  input_frame_rate_tracker_total_.Update(1);
+  input_frame_rate_tracker_.AddSamples(1);
+  input_frame_rate_tracker_total_.AddSamples(1);
   input_width_counter_.Add(width);
   input_height_counter_.Add(height);
 }
 
 void SendStatisticsProxy::OnEncodedFrame(int encode_time_ms) {
   rtc::CritScope lock(&crit_);
   encode_time_counter_.Add(encode_time_ms);
 }
 
 void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
@@ skipping 69 matching lines @@
   ++num_samples;
 }
 
 int SendStatisticsProxy::SampleCounter::Avg(int min_required_samples) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return sum / num_samples;
 }
 
 }  // namespace webrtc