Added logging of the level controller metrics

webrtc/modules/audio_processing/level_controller/level_controller.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.
  */
 
 #include "webrtc/modules/audio_processing/level_controller/level_controller.h"
 
 #include <math.h>
 #include <algorithm>
 #include <numeric>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 #include "webrtc/modules/audio_processing/level_controller/gain_applier.h"
 #include "webrtc/modules/audio_processing/level_controller/gain_selector.h"
 #include "webrtc/modules/audio_processing/level_controller/noise_level_estimator.h"
 #include "webrtc/modules/audio_processing/level_controller/peak_level_estimator.h"
 #include "webrtc/modules/audio_processing/level_controller/saturating_gain_estimator.h"
 #include "webrtc/modules/audio_processing/level_controller/signal_classifier.h"
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
+#include "webrtc/system_wrappers/include/logging.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
 
 void UpdateAndRemoveDcLevel(float forgetting_factor,
                             float* dc_level,
                             rtc::ArrayView<float> x) {
   RTC_DCHECK(!x.empty());
   float mean =
@@ skipping 48 matching lines @@
 void LevelController::Metrics::Reset() {
   metrics_frame_counter_ = 0;
   gain_sum_ = 0.f;
   peak_level_sum_ = 0.f;
   noise_energy_sum_ = 0.f;
   max_gain_ = 0.f;
   max_peak_level_ = 0.f;
   max_noise_energy_ = 0.f;
 }
 
-void LevelController::Metrics::Update(float peak_level,
+void LevelController::Metrics::Update(float long_term_peak_level,
                                       float noise_energy,
-                                      float gain) {
+                                      float gain,
+                                      float frame_peak_level) {
   const float kdBFSOffset = 90.3090f;
   gain_sum_ += gain;
-  peak_level_sum_ += peak_level;
+  peak_level_sum_ += long_term_peak_level;
   noise_energy_sum_ += noise_energy;
   max_gain_ = std::max(max_gain_, gain);
-  max_peak_level_ = std::max(max_peak_level_, peak_level);
+  max_peak_level_ = std::max(max_peak_level_, long_term_peak_level);
   max_noise_energy_ = std::max(max_noise_energy_, noise_energy);
 
   ++metrics_frame_counter_;
   if (metrics_frame_counter_ == kMetricsFrameInterval) {
-    RTC_HISTOGRAM_COUNTS(
-        "WebRTC.Audio.LevelControl.MaxNoisePower",
-        static_cast<int>(10 * log10(max_noise_energy_ / frame_length_ + 1e-10f)
-                         - kdBFSOffset),
-        -90, 0, 50);
-    RTC_HISTOGRAM_COUNTS(
-        "WebRTC.Audio.LevelControl.AverageNoisePower",
-        static_cast<int>(10 * log10(noise_energy_sum_ /
-                                    (frame_length_ * kMetricsFrameInterval) +
-                                    1e-10f) - kdBFSOffset),
-        -90, 0, 50);
+    int max_noise_power_dbfs = static_cast<int>(

[hlundin-webrtc, 2016/08/26 07:53:28]

I would argue that you should make all the local variables you calculate here
const int, just to make it clear that it is the same value that is logged to
both RTC_HISTOGRAMS and LOG.

[peah-webrtc, 2016/08/26 08:33:04]

Done.

+        10 * log10(max_noise_energy_ / frame_length_ + 1e-10f) - kdBFSOffset);

[hlundin-webrtc, 2016/08/26 07:53:28]

You are dividing by frame_length_ in a few places. I guess it can never be zero,
but please consider documenting that with an RTC_DCHECK.

[peah-webrtc, 2016/08/26 08:33:04]

Done.

+    RTC_HISTOGRAM_COUNTS("WebRTC.Audio.LevelControl.MaxNoisePower",
+                         max_noise_power_dbfs, -90, 0, 50);
 
-    RTC_HISTOGRAM_COUNTS(
-        "WebRTC.Audio.LevelControl.MaxPeakLevel",
-        static_cast<int>(10 * log10(max_peak_level_ * max_peak_level_ + 1e-10f)
-                         - kdBFSOffset),
-        -90, 0, 50);
-    RTC_HISTOGRAM_COUNTS(
-        "WebRTC.Audio.LevelControl.AveragePeakLevel",
-        static_cast<int>(10 * log10(peak_level_sum_ * peak_level_sum_ /
-                                    (kMetricsFrameInterval *
-                                     kMetricsFrameInterval) +
-                                    1e-10f) - kdBFSOffset),
-        -90, 0, 50);
+    int average_noise_power_dbfs = static_cast<int>(
+        10 * log10(noise_energy_sum_ / (frame_length_ * kMetricsFrameInterval) +
+                   1e-10f) -
+        kdBFSOffset);
+    RTC_HISTOGRAM_COUNTS("WebRTC.Audio.LevelControl.AverageNoisePower",
+                         average_noise_power_dbfs, -90, 0, 50);
+
+    int max_peak_level_dbfs = static_cast<int>(
+        10 * log10(max_peak_level_ * max_peak_level_ + 1e-10f) - kdBFSOffset);
+    RTC_HISTOGRAM_COUNTS("WebRTC.Audio.LevelControl.MaxPeakLevel",
+                         max_peak_level_dbfs, -90, 0, 50);
+
+    int average_peak_level_dbfs = static_cast<int>(
+        10 * log10(peak_level_sum_ * peak_level_sum_ /
+                       (kMetricsFrameInterval * kMetricsFrameInterval) +
+                   1e-10f) -
+        kdBFSOffset);
+    RTC_HISTOGRAM_COUNTS("WebRTC.Audio.LevelControl.AveragePeakLevel",
+                         average_peak_level_dbfs, -90, 0, 50);
 
     RTC_DCHECK_LE(1.f, max_gain_);
     RTC_DCHECK_LE(1.f, gain_sum_ / kMetricsFrameInterval);
-    RTC_HISTOGRAM_COUNTS("WebRTC.Audio.LevelControl.MaxGain",
-                         static_cast<int>(10 * log10(max_gain_ * max_gain_)),
-                         0, 33, 30);
+
+    int max_gain_db = static_cast<int>(10 * log10(max_gain_ * max_gain_));
+    RTC_HISTOGRAM_COUNTS("WebRTC.Audio.LevelControl.MaxGain", max_gain_db, 0,
+                         33, 30);
+
+    int average_gain_db = static_cast<int>(
+        10 * log10(gain_sum_ * gain_sum_ /
+                   (kMetricsFrameInterval * kMetricsFrameInterval)));
     RTC_HISTOGRAM_COUNTS("WebRTC.Audio.LevelControl.AverageGain",
-                         static_cast<int>(10 * log10(gain_sum_ * gain_sum_ /
-                                                     (kMetricsFrameInterval *
-                                                      kMetricsFrameInterval))),
-                         0, 33, 30);
+                         average_gain_db, 0, 33, 30);
+
+    int long_term_peak_level_dbfs = static_cast<int>(
+        10 * log10(long_term_peak_level * long_term_peak_level + 1e-10f) -
+        kdBFSOffset);
+
+    int frame_peak_level_dbfs = static_cast<int>(
+        10 * log10(frame_peak_level * frame_peak_level + 1e-10f) - kdBFSOffset);
+
+    LOG(LS_INFO) << "Level Controller metrics: " << std::endl
+                 << "Max noise power:              " << max_noise_power_dbfs
+                 << " dBFS" << std::endl
+                 << "Average noise power:          " << average_noise_power_dbfs
+                 << " dBFS" << std::endl
+                 << "Max long term peak level:     " << max_peak_level_dbfs
+                 << " dBFS" << std::endl
+                 << "Average long term peak level: " << average_peak_level_dbfs
+                 << " dBFS" << std::endl
+                 << "Max gain:                     " << max_gain_db << " dB"
+                 << std::endl
+                 << "Average gain:                 " << average_gain_db << " dB"
+                 << std::endl
+                 << "Last term peak level:         "

[hlundin-webrtc, 2016/08/26 07:53:29]

Last -> Long

[peah-webrtc, 2016/08/26 08:33:04]

Done.

+                 << long_term_peak_level_dbfs << " dBFS" << std::endl
+                 << "Last frame peak level:        " << frame_peak_level_dbfs
+                 << " dBFS";
+
     Reset();
   }
 }
 
 LevelController::LevelController()
     : data_dumper_(new ApmDataDumper(instance_count_)),
       gain_applier_(data_dumper_.get()),
       signal_classifier_(data_dumper_.get()) {
   Initialize(AudioProcessing::kSampleRate48kHz);
   ++instance_count_;
@@ skipping 39 matching lines @@
   SignalClassifier::SignalType signal_type;
   signal_classifier_.Analyze(*audio, &signal_type);
   int tmp = static_cast<int>(signal_type);
   data_dumper_->DumpRaw("lc_signal_type", 1, &tmp);
 
   // Estimate the noise energy.
   float noise_energy =
       noise_level_estimator_.Analyze(signal_type, FrameEnergy(*audio));
 
   // Estimate the overall signal peak level.
-  float peak_level =
-      peak_level_estimator_.Analyze(signal_type, PeakLevel(*audio));
+  float frame_peak_level = PeakLevel(*audio);

[hlundin-webrtc, 2016/08/26 07:53:29]

const

[peah-webrtc, 2016/08/26 08:33:04]

Done.

+  float long_term_peak_level =

[hlundin-webrtc, 2016/08/26 07:53:29]

const

[peah-webrtc, 2016/08/26 08:33:04]

Done.

+      peak_level_estimator_.Analyze(signal_type, frame_peak_level);
 
   float saturating_gain = saturating_gain_estimator_.GetGain();
 
   // Compute the new gain to apply.
-  last_gain_ = gain_selector_.GetNewGain(peak_level, noise_energy,
+  last_gain_ = gain_selector_.GetNewGain(long_term_peak_level, noise_energy,
                                          saturating_gain, signal_type);
 
   // Apply the gain to the signal.
   int num_saturations = gain_applier_.Process(last_gain_, audio);
 
   // Estimate the gain that saturates the overall signal.
   saturating_gain_estimator_.Update(last_gain_, num_saturations);
 
   // Update the metrics.
-  metrics_.Update(peak_level, noise_energy, last_gain_);
+  metrics_.Update(long_term_peak_level, noise_energy, last_gain_,
+                  frame_peak_level);
 
   data_dumper_->DumpRaw("lc_selected_gain", 1, &last_gain_);
   data_dumper_->DumpRaw("lc_noise_energy", 1, &noise_energy);
-  data_dumper_->DumpRaw("lc_peak_level", 1, &peak_level);
+  data_dumper_->DumpRaw("lc_peak_level", 1, &long_term_peak_level);
   data_dumper_->DumpRaw("lc_saturating_gain", 1, &saturating_gain);
 
   data_dumper_->DumpWav("lc_output", audio->num_frames(),
                         audio->channels_f()[0], *sample_rate_hz_, 1);
 }
 
 }  // namespace webrtc