Added histogram for the output level int the audio processing module

webrtc/modules/audio_processing/audio_processing_impl.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.
  */
 
@@ skipping 1114 matching lines @@
         public_submodules_->echo_cancellation->stream_drift_samples());
     msg->set_level(gain_control()->stream_analog_level());
     msg->set_keypress(capture_.key_pressed);
   }
 #endif
 
   MaybeUpdateHistograms();
 
   AudioBuffer* capture_buffer = capture_.capture_audio.get();  // For brevity.
 
-  rms_.Analyze(rtc::ArrayView<const int16_t>(
+  capture_input_rms_.Analyze(rtc::ArrayView<const int16_t>(
       capture_buffer->channels_const()[0],
       capture_nonlocked_.capture_processing_format.num_frames()));
-  if (++rms_interval_counter_ >= 1000) {
-    rms_interval_counter_ = 0;
-    RmsLevel::Levels levels = rms_.AverageAndPeak();
+  if (++capture_rms_interval_counter_ >= 1000) {

[hlundin-webrtc, 2016/12/20 14:41:26]

This feels a bit fragile now, with incrementing in one place, and resetting 100+
lines later. I suggest the following:

const bool log_rms = ++capture_rms_interval_counter_ >= 1000;
if (log_rms) {
  capture_rms_interval_counter_ = 0;
  // Do the input level logging...
}

...

And then use the same log_rms in the new logging below.

[peah-webrtc, 2016/12/20 14:46:47]

Great point and suggestion!
Done.

+    RmsLevel::Levels levels = capture_input_rms_.AverageAndPeak();
     RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.ApmCaptureInputLevelAverageRms",
                                 levels.average, 1, RmsLevel::kMinLevelDb, 64);
     RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.ApmCaptureInputLevelPeakRms",
                                 levels.peak, 1, RmsLevel::kMinLevelDb, 64);
   }
 
   if (private_submodules_->echo_canceller3) {
     private_submodules_->echo_canceller3->AnalyzeCapture(capture_buffer);
   }
 
@@ skipping 117 matching lines @@
         capture_.key_pressed);
   }
 
   if (capture_nonlocked_.level_controller_enabled) {
     private_submodules_->level_controller->Process(capture_buffer);
   }
 
   // The level estimator operates on the recombined data.
   public_submodules_->level_estimator->ProcessStream(capture_buffer);
 
+  capture_output_rms_.Analyze(rtc::ArrayView<const int16_t>(
+      capture_buffer->channels_const()[0],
+      capture_nonlocked_.capture_processing_format.num_frames()));
+  if (capture_rms_interval_counter_ >= 1000) {
+    capture_rms_interval_counter_ = 0;
+    RmsLevel::Levels levels = capture_output_rms_.AverageAndPeak();
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.ApmCaptureOutputLevelAverageRms",
+                                levels.average, 1, RmsLevel::kMinLevelDb, 64);
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.ApmCaptureOutputLevelPeakRms",
+                                levels.peak, 1, RmsLevel::kMinLevelDb, 64);
+  }
+
   capture_.was_stream_delay_set = false;
   return kNoError;
 }
 
 int AudioProcessingImpl::AnalyzeReverseStream(const float* const* data,
                                               size_t samples_per_channel,
                                               int sample_rate_hz,
                                               ChannelLayout layout) {
   TRACE_EVENT0("webrtc", "AudioProcessing::AnalyzeReverseStream_ChannelLayout");
   rtc::CritScope cs(&crit_render_);
@@ skipping 671 matching lines @@
       capture_processing_format(kSampleRate16kHz),
       split_rate(kSampleRate16kHz) {}
 
 AudioProcessingImpl::ApmCaptureState::~ApmCaptureState() = default;
 
 AudioProcessingImpl::ApmRenderState::ApmRenderState() = default;
 
 AudioProcessingImpl::ApmRenderState::~ApmRenderState() = default;
 
 }  // namespace webrtc