Use RateAccCounter for sent bitrate stats. Reports average of periodically computed stats over a ca…

webrtc/video/stats_counter.cc

 /*
  *  Copyright (c) 2016 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 70 matching lines @@
 // Class holding gathered samples within a process interval.
 class Samples {
  public:
   Samples() : total_count_(0) {}
   ~Samples() {}
 
   void Add(int sample, uint32_t stream_id) {
     samples_[stream_id].Add(sample);
     ++total_count_;
   }
-  void Set(int sample, uint32_t stream_id) {
+  void Set(int64_t sample, uint32_t stream_id) {
     samples_[stream_id].Set(sample);
     ++total_count_;
   }
+  void SetLast(int64_t sample, uint32_t stream_id) {
+    samples_[stream_id].SetLast(sample);
+  }
+  int64_t GetLast(uint32_t stream_id) { return samples_[stream_id].GetLast(); }
 
   int64_t Count() const { return total_count_; }
   bool Empty() const { return total_count_ == 0; }
 
   int64_t Sum() const {
     int64_t sum = 0;
     for (const auto& it : samples_)
       sum += it.second.sum_;
     return sum;
   }
@@ skipping 26 matching lines @@
     return (count > 0) ? sum_diff : -1;
   }
 
  private:
   struct Stats {
     void Add(int sample) {
       sum_ += sample;
       ++count_;
       max_ = std::max(sample, max_);
     }
-    void Set(int sample) {
+    void Set(int64_t sample) {
       sum_ = sample;
       ++count_;
     }
+    void SetLast(int64_t sample) { last_sum_ = sample; }
+    int64_t GetLast() const { return last_sum_; }
     void Reset() {
       if (count_ > 0)
         last_sum_ = sum_;
       sum_ = 0;
       count_ = 0;
       max_ = std::numeric_limits<int>::min();
     }
 
     int max_ = std::numeric_limits<int>::min();
     int64_t count_ = 0;
@@ skipping 10 matching lines @@
                            int64_t process_intervals_ms,
                            bool include_empty_intervals,
                            StatsCounterObserver* observer)
     : include_empty_intervals_(include_empty_intervals),
       process_intervals_ms_(process_intervals_ms),
       aggregated_counter_(new AggregatedCounter()),
       samples_(new Samples()),
       clock_(clock),
       observer_(observer),
       last_process_time_ms_(-1),
-      paused_(false) {
+      paused_(false),
+      pause_time_ms_(-1),
+      min_pause_time_ms_(0) {
   RTC_DCHECK_GT(process_intervals_ms_, 0);
 }
 
 StatsCounter::~StatsCounter() {}
 
 AggregatedStats StatsCounter::GetStats() {
   return aggregated_counter_->ComputeStats();
 }
 
 AggregatedStats StatsCounter::ProcessAndGetStats() {
   if (HasSample())
     TryProcess();
   return aggregated_counter_->ComputeStats();
 }
 
+void StatsCounter::ProcessAndPauseForDuration(int64_t min_pause_time_ms) {
+  ProcessAndPause();
+  min_pause_time_ms_ = min_pause_time_ms;
+}
+
 void StatsCounter::ProcessAndPause() {
   if (HasSample())
     TryProcess();
   paused_ = true;
+  pause_time_ms_ = clock_->TimeInMilliseconds();
+}
+
+void StatsCounter::ProcessAndStopPause() {
+  if (HasSample())
+    TryProcess();
+  Resume();
 }
 
 bool StatsCounter::HasSample() const {
   return last_process_time_ms_ != -1;
 }
 
 bool StatsCounter::TimeToProcess(int* elapsed_intervals) {
   int64_t now = clock_->TimeInMilliseconds();
   if (last_process_time_ms_ == -1)
     last_process_time_ms_ = now;
 
   int64_t diff_ms = now - last_process_time_ms_;
   if (diff_ms < process_intervals_ms_)
     return false;
 
   // Advance number of complete |process_intervals_ms_| that have passed.
   int64_t num_intervals = diff_ms / process_intervals_ms_;
   last_process_time_ms_ += num_intervals * process_intervals_ms_;
 
   *elapsed_intervals = num_intervals;
   return true;
 }
 
-void StatsCounter::Set(int sample, uint32_t stream_id) {
-  TryProcess();
-  samples_->Set(sample, stream_id);
-  paused_ = false;
-}
-
 void StatsCounter::Add(int sample) {
   TryProcess();
   samples_->Add(sample, kStreamId0);
-  paused_ = false;
+  ResumeIfMinTimePassed();
+}
+
+void StatsCounter::Set(int64_t sample, uint32_t stream_id) {
+  if (paused_ && sample == samples_->GetLast(stream_id)) {
+    // Do not add same sample while paused (will reset pause).
+    return;
+  }
+  TryProcess();
+  samples_->Set(sample, stream_id);
+  ResumeIfMinTimePassed();
+}
+
+void StatsCounter::SetLast(int64_t sample, uint32_t stream_id) {
+  RTC_DCHECK(!HasSample()) << "Should be set before first sample is added.";
+  samples_->SetLast(sample, stream_id);
 }
 
 // Reports periodically computed metric.
 void StatsCounter::ReportMetricToAggregatedCounter(
     int value,
     int num_values_to_add) const {
   for (int i = 0; i < num_values_to_add; ++i) {
     aggregated_counter_->Add(value);
     if (observer_)
       observer_->OnMetricUpdated(value);
@@ skipping 20 matching lines @@
                                     empty_intervals);
   }
 
   // Reset samples for elapsed interval.
   samples_->Reset();
 }
 
 bool StatsCounter::IncludeEmptyIntervals() const {
   return include_empty_intervals_ && !paused_ && !aggregated_counter_->Empty();
 }
+void StatsCounter::ResumeIfMinTimePassed() {
+  if (paused_ &&
+      (clock_->TimeInMilliseconds() - pause_time_ms_) >= min_pause_time_ms_) {
+    Resume();
+  }
+}
+
+void StatsCounter::Resume() {
+  paused_ = false;
+  min_pause_time_ms_ = 0;
+}
 
 // StatsCounter sub-classes.
 AvgCounter::AvgCounter(Clock* clock,
                        StatsCounterObserver* observer,
                        bool include_empty_intervals)
     : StatsCounter(clock,
                    kDefaultProcessIntervalMs,
                    include_empty_intervals,
                    observer) {}
 
@@ skipping 113 matching lines @@
 }
 
 RateAccCounter::RateAccCounter(Clock* clock,
                                StatsCounterObserver* observer,
                                bool include_empty_intervals)
     : StatsCounter(clock,
                    kDefaultProcessIntervalMs,
                    include_empty_intervals,
                    observer) {}
 
-void RateAccCounter::Set(int sample, uint32_t stream_id) {
+void RateAccCounter::Set(int64_t sample, uint32_t stream_id) {
   StatsCounter::Set(sample, stream_id);
 }
 
+void RateAccCounter::SetLast(int64_t sample, uint32_t stream_id) {
+  StatsCounter::SetLast(sample, stream_id);
+}
+
 bool RateAccCounter::GetMetric(int* metric) const {
   int64_t diff = samples_->Diff();
   if (diff < 0 || (!include_empty_intervals_ && diff == 0))
     return false;
 
   *metric = (diff * 1000 + process_intervals_ms_ / 2) / process_intervals_ms_;
   return true;
 }
 
 int RateAccCounter::GetValueForEmptyInterval() const {
   return 0;
 }
 
 }  // namespace webrtc