NetEq/ACM: Refactor how packet waiting times are calculated

webrtc/modules/audio_coding/neteq/statistics_calculator.cc

Index: webrtc/modules/audio_coding/neteq/statistics_calculator.cc
diff --git a/webrtc/modules/audio_coding/neteq/statistics_calculator.cc b/webrtc/modules/audio_coding/neteq/statistics_calculator.cc
index df139f7bbafcc457ac729a8755cfa828bc01d821..b923656f403ecf32e5e561780dc48119a575c958 100644
--- a/webrtc/modules/audio_coding/neteq/statistics_calculator.cc
+++ b/webrtc/modules/audio_coding/neteq/statistics_calculator.cc
@@ -12,6 +12,8 @@
 
 #include <assert.h>
 #include <string.h>  // memset
+#include <algorithm>
+#include <iterator>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/audio_coding/neteq/decision_logic.h"
@@ -20,6 +22,9 @@
 
 namespace webrtc {
 
+// Allocating the static const so that it can be passed by reference to DCHECK.
+const size_t StatisticsCalculator::kLenWaitingTimes;
+
 StatisticsCalculator::PeriodicUmaLogger::PeriodicUmaLogger(
     const std::string& uma_name,
     int report_interval_ms,
@@ -106,8 +111,6 @@ StatisticsCalculator::StatisticsCalculator()
       discarded_packets_(0),
       lost_timestamps_(0),
       timestamps_since_last_report_(0),
-      len_waiting_times_(0),
-      next_waiting_time_index_(0),
       secondary_decoded_samples_(0),
       delayed_packet_outage_counter_(
           "WebRTC.Audio.DelayedPacketOutageEventsPerMinute",
@@ -116,9 +119,10 @@ StatisticsCalculator::StatisticsCalculator()
       excess_buffer_delay_("WebRTC.Audio.AverageExcessBufferDelayMs",
                            60000,  // 60 seconds report interval.
                            1000) {
-  memset(waiting_times_, 0, kLenWaitingTimes * sizeof(waiting_times_[0]));
 }
 
+StatisticsCalculator::~StatisticsCalculator() = default;
+
 void StatisticsCalculator::Reset() {
   preemptive_samples_ = 0;
   accelerate_samples_ = 0;
@@ -126,6 +130,7 @@ void StatisticsCalculator::Reset() {
   expanded_speech_samples_ = 0;
   expanded_noise_samples_ = 0;
   secondary_decoded_samples_ = 0;
+  waiting_times_.clear();
 }
 
 void StatisticsCalculator::ResetMcu() {
@@ -134,12 +139,6 @@ void StatisticsCalculator::ResetMcu() {
   timestamps_since_last_report_ = 0;
 }
 
-void StatisticsCalculator::ResetWaitingTimeStatistics() {
-  memset(waiting_times_, 0, kLenWaitingTimes * sizeof(waiting_times_[0]));
-  len_waiting_times_ = 0;
-  next_waiting_time_index_ = 0;
-}
-
 void StatisticsCalculator::ExpandedVoiceSamples(int num_samples) {
   expanded_speech_samples_ += num_samples;
 }
@@ -194,15 +193,12 @@ void StatisticsCalculator::LogDelayedPacketOutageEvent(int outage_duration_ms) {
 
 void StatisticsCalculator::StoreWaitingTime(int waiting_time_ms) {
   excess_buffer_delay_.RegisterSample(waiting_time_ms);
-  assert(next_waiting_time_index_ < kLenWaitingTimes);
-  waiting_times_[next_waiting_time_index_] = waiting_time_ms;
-  next_waiting_time_index_++;
-  if (next_waiting_time_index_ >= kLenWaitingTimes) {
-    next_waiting_time_index_ = 0;
-  }
-  if (len_waiting_times_ < kLenWaitingTimes) {
-    len_waiting_times_++;
+  DCHECK_LE(waiting_times_.size(), kLenWaitingTimes);
+  while (waiting_times_.size() >= kLenWaitingTimes) {
+    // Erase first value.
+    waiting_times_.pop_front();
   }
+  waiting_times_.push_back(waiting_time_ms);
 }
 
 void StatisticsCalculator::GetNetworkStatistics(
@@ -252,19 +248,37 @@ void StatisticsCalculator::GetNetworkStatistics(
       CalculateQ14Ratio(secondary_decoded_samples_,
                         timestamps_since_last_report_);
 
+  if (waiting_times_.size() == 0) {
+    stats->mean_waiting_time_ms = -1;
+    stats->median_waiting_time_ms = -1;
+    stats->min_waiting_time_ms = -1;
+    stats->max_waiting_time_ms = -1;
+  } else {
+    std::sort(waiting_times_.begin(), waiting_times_.end());
+    // Find mid-point elements. If the size is odd, the two iterators
+    // |middle_left| and |middle_right| will both point to the middle element
+    // after these operations; if the size is even, they will point to the two
+    // neighboring elements at the middle of the list.
+    auto middle_left = waiting_times_.begin();
+    std::advance(middle_left, (waiting_times_.size() - 1) / 2);

[ivoc, 2015/08/24 14:22:17]

I think this can be simplified to:
int middle_left = waiting_times_[(waiting_times_.size() - 1) / 2];
and:
int middle_right = waiting_times_[waiting_times_.size() / 2];

[minyue-webrtc, 2015/08/24 15:02:54]

+1

[hlundin-webrtc, 2015/08/24 15:27:50]

Thanks! I had to use std::advance when I used std::list, but now that I use
std::deque, the [] is available.

+    auto middle_right = waiting_times_.rbegin();
+    std::advance(middle_right, (waiting_times_.size() - 1) / 2);
+    // Calculate the average of the two. (Works also for odd sizes.)
+    stats->median_waiting_time_ms = (*middle_left + *middle_right) / 2;
+    stats->min_waiting_time_ms = waiting_times_.front();
+    stats->max_waiting_time_ms = waiting_times_.back();
+    double sum = 0;
+    for (auto time : waiting_times_) {
+      sum += time;
+    }
+    stats->mean_waiting_time_ms = static_cast<int>(sum / waiting_times_.size());
+  }
+
   // Reset counters.
   ResetMcu();
   Reset();
 }
 
-void StatisticsCalculator::WaitingTimes(std::vector<int>* waiting_times) {
-  if (!waiting_times) {
-    return;
-  }
-  waiting_times->assign(waiting_times_, waiting_times_ + len_waiting_times_);
-  ResetWaitingTimeStatistics();
-}
-
 uint16_t StatisticsCalculator::CalculateQ14Ratio(uint32_t numerator,
                                                  uint32_t denominator) {
   if (numerator == 0) {