NetEq: Use TickTimer in DelayManager

webrtc/modules/audio_coding/neteq/delay_manager.cc

 /*
  *  Copyright (c) 2012 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/delay_manager.h"
 
 #include <assert.h>
 #include <math.h>
 
 #include <algorithm>  // max, min
 
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/neteq/delay_peak_detector.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 
 DelayManager::DelayManager(size_t max_packets_in_buffer,
-                           DelayPeakDetector* peak_detector)
+                           DelayPeakDetector* peak_detector,
+                           const TickTimer* tick_timer)
     : first_packet_received_(false),
       max_packets_in_buffer_(max_packets_in_buffer),
       iat_vector_(kMaxIat + 1, 0),
       iat_factor_(0),
-      packet_iat_count_ms_(0),
+      tick_timer_(tick_timer),
       base_target_level_(4),  // In Q0 domain.
       target_level_(base_target_level_ << 8),  // In Q8 domain.
       packet_len_ms_(0),
       streaming_mode_(false),
       last_seq_no_(0),
       last_timestamp_(0),
       minimum_delay_ms_(0),
       least_required_delay_ms_(target_level_),
       maximum_delay_ms_(target_level_),
       iat_cumulative_sum_(0),
       max_iat_cumulative_sum_(0),
-      max_timer_ms_(0),
       peak_detector_(*peak_detector),
       last_pack_cng_or_dtmf_(1) {
   assert(peak_detector);  // Should never be NULL.
   Reset();
 }
 
 DelayManager::~DelayManager() {}
 
 const DelayManager::IATVector& DelayManager::iat_vector() const {
   return iat_vector_;
@@ skipping 17 matching lines @@
 
 int DelayManager::Update(uint16_t sequence_number,
                          uint32_t timestamp,
                          int sample_rate_hz) {
   if (sample_rate_hz <= 0) {
     return -1;
   }
 
   if (!first_packet_received_) {
     // Prepare for next packet arrival.
-    packet_iat_count_ms_ = 0;
+    packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
     last_seq_no_ = sequence_number;
     last_timestamp_ = timestamp;
     first_packet_received_ = true;
     return 0;
   }
 
   // Try calculating packet length from current and previous timestamps.
   int packet_len_ms;
   if (!IsNewerTimestamp(timestamp, last_timestamp_) ||
       !IsNewerSequenceNumber(sequence_number, last_seq_no_)) {
     // Wrong timestamp or sequence order; use stored value.
     packet_len_ms = packet_len_ms_;
   } else {
     // Calculate timestamps per packet and derive packet length in ms.
     int64_t packet_len_samp =
         static_cast<uint32_t>(timestamp - last_timestamp_) /
         static_cast<uint16_t>(sequence_number - last_seq_no_);
     packet_len_ms =
         rtc::checked_cast<int>(1000 * packet_len_samp / sample_rate_hz);
   }
 
   if (packet_len_ms > 0) {
     // Cannot update statistics unless |packet_len_ms| is valid.
     // Calculate inter-arrival time (IAT) in integer "packet times"
     // (rounding down). This is the value used as index to the histogram
     // vector |iat_vector_|.
-    int iat_packets = packet_iat_count_ms_ / packet_len_ms;
+    int iat_packets = packet_iat_stopwatch_->ElapsedMs() / packet_len_ms;
 
     if (streaming_mode_) {
       UpdateCumulativeSums(packet_len_ms, sequence_number);
     }
 
     // Check for discontinuous packet sequence and re-ordering.
     if (IsNewerSequenceNumber(sequence_number, last_seq_no_ + 1)) {
       // Compensate for gap in the sequence numbers. Reduce IAT with the
       // expected extra time due to lost packets, but ensure that the IAT is
       // not negative.
@@ skipping 10 matching lines @@
     // Calculate new |target_level_| based on updated statistics.
     target_level_ = CalculateTargetLevel(iat_packets);
     if (streaming_mode_) {
       target_level_ = std::max(target_level_, max_iat_cumulative_sum_);
     }
 
     LimitTargetLevel();
   }  // End if (packet_len_ms > 0).
 
   // Prepare for next packet arrival.
-  packet_iat_count_ms_ = 0;
+  packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
   last_seq_no_ = sequence_number;
   last_timestamp_ = timestamp;
   return 0;
 }
 
 void DelayManager::UpdateCumulativeSums(int packet_len_ms,
                                         uint16_t sequence_number) {
   // Calculate IAT in Q8, including fractions of a packet (i.e., more
   // accurate than |iat_packets|.
-  int iat_packets_q8 = (packet_iat_count_ms_ << 8) / packet_len_ms;
+  int iat_packets_q8 =
+      (packet_iat_stopwatch_->ElapsedMs() << 8) / packet_len_ms;
   // Calculate cumulative sum IAT with sequence number compensation. The sum
   // is zero if there is no clock-drift.
   iat_cumulative_sum_ += (iat_packets_q8 -
       (static_cast<int>(sequence_number - last_seq_no_) << 8));
   // Subtract drift term.
   iat_cumulative_sum_ -= kCumulativeSumDrift;
   // Ensure not negative.
   iat_cumulative_sum_ = std::max(iat_cumulative_sum_, 0);
   if (iat_cumulative_sum_ > max_iat_cumulative_sum_) {
     // Found a new maximum.
     max_iat_cumulative_sum_ = iat_cumulative_sum_;
-    max_timer_ms_ = 0;
+    max_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
   }
-  if (max_timer_ms_ > kMaxStreamingPeakPeriodMs) {
+  if (max_iat_stopwatch_->ElapsedMs() > kMaxStreamingPeakPeriodMs) {
     // Too long since the last maximum was observed; decrease max value.
     max_iat_cumulative_sum_ -= kCumulativeSumDrift;
   }
 }
 
 // Each element in the vector is first multiplied by the forgetting factor
 // |iat_factor_|. Then the vector element indicated by |iat_packets| is then
 // increased (additive) by 1 - |iat_factor_|. This way, the probability of
 // |iat_packets| is slightly increased, while the sum of the histogram remains
 // constant (=1).
@@ skipping 117 matching lines @@
   return target_level_;
 }
 
 int DelayManager::SetPacketAudioLength(int length_ms) {
   if (length_ms <= 0) {
     LOG_F(LS_ERROR) << "length_ms = " << length_ms;
     return -1;
   }
   packet_len_ms_ = length_ms;
   peak_detector_.SetPacketAudioLength(packet_len_ms_);
-  packet_iat_count_ms_ = 0;
+  packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
   last_pack_cng_or_dtmf_ = 1;  // TODO(hlundin): Legacy. Remove?
   return 0;
 }
 
 
 void DelayManager::Reset() {
   packet_len_ms_ = 0;  // Packet size unknown.
   streaming_mode_ = false;
   peak_detector_.Reset();
   ResetHistogram();  // Resets target levels too.
   iat_factor_ = 0;  // Adapt the histogram faster for the first few packets.
-  packet_iat_count_ms_ = 0;
-  max_timer_ms_ = 0;
+  packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
+  max_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
   iat_cumulative_sum_ = 0;
   max_iat_cumulative_sum_ = 0;
   last_pack_cng_or_dtmf_ = 1;
 }
 
 int DelayManager::AverageIAT() const {
   int32_t sum_q24 = 0;
   // Using an int for the upper limit of the following for-loop so the
   // loop-counter can be int. Otherwise we need a cast where |sum_q24| is
   // updated.
   const int iat_vec_size = static_cast<int>(iat_vector_.size());
   assert(iat_vector_.size() == 65);  // Algorithm is hard-coded for this size.
   for (int i = 0; i < iat_vec_size; ++i) {
     // Shift 6 to fit worst case: 2^30 * 64.
     sum_q24 += (iat_vector_[i] >> 6) * i;
   }
   // Subtract the nominal inter-arrival time 1 = 2^24 in Q24.
   sum_q24 -= (1 << 24);
   // Multiply with 1000000 / 2^24 = 15625 / 2^18 to get in parts-per-million.
   // Shift 7 to Q17 first, then multiply with 15625 and shift another 11.
   return ((sum_q24 >> 7) * 15625) >> 11;
 }
 
 bool DelayManager::PeakFound() const {
   return peak_detector_.peak_found();
 }
 
-void DelayManager::UpdateCounters(int elapsed_time_ms) {
-  packet_iat_count_ms_ += elapsed_time_ms;
-  max_timer_ms_ += elapsed_time_ms;
+void DelayManager::ResetPacketIatCount() {
+  packet_iat_stopwatch_ = tick_timer_->GetNewStopwatch();
 }
 
-void DelayManager::ResetPacketIatCount() { packet_iat_count_ms_ = 0; }
-
 // Note that |low_limit| and |higher_limit| are not assigned to
 // |minimum_delay_ms_| and |maximum_delay_ms_| defined by the client of this
 // class. They are computed from |target_level_| and used for decision making.
 void DelayManager::BufferLimits(int* lower_limit, int* higher_limit) const {
   if (!lower_limit || !higher_limit) {
     LOG_F(LS_ERROR) << "NULL pointers supplied as input";
     assert(false);
     return;
   }
 
@@ skipping 59 matching lines @@
 int DelayManager::base_target_level() const { return base_target_level_; }
 void DelayManager::set_streaming_mode(bool value) { streaming_mode_ = value; }
 int DelayManager::last_pack_cng_or_dtmf() const {
   return last_pack_cng_or_dtmf_;
 }
 
 void DelayManager::set_last_pack_cng_or_dtmf(int value) {
   last_pack_cng_or_dtmf_ = value;
 }
 }  // namespace webrtc