NetEq: Implement logging of Delayed Packet Outage Events

webrtc/modules/audio_coding/neteq/expand.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/expand.h"
 
 #include <assert.h>
 #include <string.h>  // memset
 
 #include <algorithm>  // min, max
 #include <limits>  // numeric_limits<T>
 
+#include "webrtc/base/safe_conversions.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/neteq/background_noise.h"
 #include "webrtc/modules/audio_coding/neteq/dsp_helper.h"
 #include "webrtc/modules/audio_coding/neteq/random_vector.h"
+#include "webrtc/modules/audio_coding/neteq/statistics_calculator.h"
 #include "webrtc/modules/audio_coding/neteq/sync_buffer.h"
 
 namespace webrtc {
 
 Expand::Expand(BackgroundNoise* background_noise,
                SyncBuffer* sync_buffer,
                RandomVector* random_vector,
+               StatisticsCalculator* statistics,
                int fs,
                size_t num_channels)
     : random_vector_(random_vector),
       sync_buffer_(sync_buffer),
       first_expand_(true),
       fs_hz_(fs),
       num_channels_(num_channels),
       consecutive_expands_(0),
       background_noise_(background_noise),
+      statistics_(statistics),
       overlap_length_(5 * fs / 8000),
       lag_index_direction_(0),
       current_lag_index_(0),
       stop_muting_(false),
+      expand_duration_samples_(0),
       channel_parameters_(new ChannelParameters[num_channels_]) {
   assert(fs == 8000 || fs == 16000 || fs == 32000 || fs == 48000);
   assert(fs <= kMaxSampleRate);  // Should not be possible.
   assert(num_channels_ > 0);
   memset(expand_lags_, 0, sizeof(expand_lags_));
   Reset();
 }
 
 Expand::~Expand() = default;
 
@@ skipping 18 matching lines @@
   int16_t unvoiced_array_memory[kNoiseLpcOrder + kMaxSampleRate / 8000 * 125];
   int16_t* unvoiced_vector = unvoiced_array_memory + kUnvoicedLpcOrder;
   int16_t* noise_vector = unvoiced_array_memory + kNoiseLpcOrder;
 
   int fs_mult = fs_hz_ / 8000;
 
   if (first_expand_) {
     // Perform initial setup if this is the first expansion since last reset.
     AnalyzeSignal(random_vector);
     first_expand_ = false;
+    expand_duration_samples_ = 0;
   } else {
     // This is not the first expansion, parameters are already estimated.
     // Extract a noise segment.
     int16_t rand_length = max_lag_;
     // This only applies to SWB where length could be larger than 256.
     assert(rand_length <= kMaxSampleRate / 8000 * 120 + 30);
     GenerateRandomVector(2, rand_length, random_vector);
   }
 
 
@@ skipping 200 matching lines @@
     } else {
       assert(output->Size() == current_lag);
     }
     memcpy(&(*output)[channel_ix][0], temp_data,
            sizeof(temp_data[0]) * current_lag);
   }
 
   // Increase call number and cap it.
   consecutive_expands_ = consecutive_expands_ >= kMaxConsecutiveExpands ?
       kMaxConsecutiveExpands : consecutive_expands_ + 1;
+  expand_duration_samples_ += output->Size();
+  // Clamp the duration counter at 2 seconds.
+  expand_duration_samples_ =
+      std::min(expand_duration_samples_, rtc::checked_cast<size_t>(fs_hz_ * 2));
   return 0;
 }
 
 void Expand::SetParametersForNormalAfterExpand() {
   current_lag_index_ = 0;
   lag_index_direction_ = 0;
   stop_muting_ = true;  // Do not mute signal any more.
+  statistics_->LogDelayedPacketOutageEvent(
+      rtc::checked_cast<int>(expand_duration_samples_) / (fs_hz_ / 1000));
 }
 
 void Expand::SetParametersForMergeAfterExpand() {
   current_lag_index_ = -1; /* out of the 3 possible ones */
   lag_index_direction_ = 1; /* make sure we get the "optimal" lag */
   stop_muting_ = true;
 }
 
 size_t Expand::overlap_length() const {
   return overlap_length_;
@@ skipping 508 matching lines @@
     lag_index_direction_ = 1;
   }
   if (current_lag_index_ >= kNumLags - 1) {
     lag_index_direction_ = -1;
   }
 }
 
 Expand* ExpandFactory::Create(BackgroundNoise* background_noise,
                               SyncBuffer* sync_buffer,
                               RandomVector* random_vector,
+                              StatisticsCalculator* statistics,
                               int fs,
                               size_t num_channels) const {
-  return new Expand(background_noise, sync_buffer, random_vector, fs,
-                    num_channels);
+  return new Expand(background_noise, sync_buffer, random_vector, statistics,
+                    fs, num_channels);
 }
 
 // TODO(turajs): This can be moved to BackgroundNoise class.
 void Expand::GenerateBackgroundNoise(int16_t* random_vector,
                                      size_t channel,
                                      int mute_slope,
                                      bool too_many_expands,
                                      size_t num_noise_samples,
                                      int16_t* buffer) {
   static const int kNoiseLpcOrder = BackgroundNoise::kMaxLpcOrder;
@@ skipping 88 matching lines @@
   const size_t kMaxRandSamples = RandomVector::kRandomTableSize;
   while (samples_generated < length) {
     size_t rand_length = std::min(length - samples_generated, kMaxRandSamples);
     random_vector_->IncreaseSeedIncrement(seed_increment);
     random_vector_->Generate(rand_length, &random_vector[samples_generated]);
     samples_generated += rand_length;
   }
 }
 
 }  // namespace webrtc