NetEq/ACM: Refactor how packet waiting times are calculated

webrtc/modules/audio_coding/neteq/statistics_calculator.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/modules/audio_coding/neteq/statistics_calculator.h"
 
 #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"
 #include "webrtc/modules/audio_coding/neteq/delay_manager.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
 
 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,
     int max_value)
     : uma_name_(uma_name),
       report_interval_ms_(report_interval_ms),
       max_value_(max_value),
       timer_(0) {
 }
 
@@ skipping 66 matching lines @@
 
 StatisticsCalculator::StatisticsCalculator()
     : preemptive_samples_(0),
       accelerate_samples_(0),
       added_zero_samples_(0),
       expanded_speech_samples_(0),
       expanded_noise_samples_(0),
       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",
           60000,  // 60 seconds report interval.
           100),
       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;
   added_zero_samples_ = 0;
   expanded_speech_samples_ = 0;
   expanded_noise_samples_ = 0;
   secondary_decoded_samples_ = 0;
+  waiting_times_.clear();
 }
 
 void StatisticsCalculator::ResetMcu() {
   discarded_packets_ = 0;
   lost_timestamps_ = 0;
   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;
 }
 
 void StatisticsCalculator::ExpandedNoiseSamples(int num_samples) {
   expanded_noise_samples_ += num_samples;
 }
 
 void StatisticsCalculator::PreemptiveExpandedSamples(int num_samples) {
   preemptive_samples_ += num_samples;
@@ skipping 34 matching lines @@
 
 void StatisticsCalculator::LogDelayedPacketOutageEvent(int outage_duration_ms) {
   RTC_HISTOGRAM_COUNTS("WebRTC.Audio.DelayedPacketOutageEventMs",
                        outage_duration_ms, 1 /* min */, 2000 /* max */,
                        100 /* bucket count */);
   delayed_packet_outage_counter_.RegisterSample();
 }
 
 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;
+  DCHECK_LE(waiting_times_.size(), kLenWaitingTimes);
+  while (waiting_times_.size() >= kLenWaitingTimes) {
+    // Erase first value.
+    waiting_times_.pop_front();
   }
-  if (len_waiting_times_ < kLenWaitingTimes) {
-    len_waiting_times_++;
-  }
+  waiting_times_.push_back(waiting_time_ms);
 }
 
 void StatisticsCalculator::GetNetworkStatistics(
     int fs_hz,
     int num_samples_in_buffers,
     int samples_per_packet,
     const DelayManager& delay_manager,
     const DecisionLogic& decision_logic,
     NetEqNetworkStatistics *stats) {
   if (fs_hz <= 0 || !stats) {
@@ skipping 29 matching lines @@
                         timestamps_since_last_report_);
 
   stats->speech_expand_rate =
       CalculateQ14Ratio(expanded_speech_samples_,
                         timestamps_since_last_report_);
 
   stats->secondary_decoded_rate =
       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) {
     return 0;
   } else if (numerator < denominator) {
     // Ratio must be smaller than 1 in Q14.
     assert((numerator << 14) / denominator < (1 << 14));
     return static_cast<uint16_t>((numerator << 14) / denominator);
   } else {
     // Will not produce a ratio larger than 1, since this is probably an error.
     return 1 << 14;
   }
 }
 
 }  // namespace webrtc