Adding media.MicrophoneVolume UMA stat

media/audio/audio_input_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/audio_input_controller.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 28 matching lines @@
 // constant given by |kPowerMeasurementTimeConstantMilliseconds|.
 // Example: fs=44100, ts=10e-3 => alpha~0.022420
 //          fs=44100, ts=20e-3 => alpha~0.165903
 // A large smoothing factor corresponds to a faster filter response to input
 // changes since y(n)=alpha*x(n)+(1-alpha)*y(n-1), where x(n) is the input
 // and y(n) is the output.
 const int kPowerMeasurementTimeConstantMilliseconds = 10;
 
 // Time in seconds between two successive measurements of audio power levels.
 const int kPowerMonitorLogIntervalSeconds = 15;
+
+// A warning will be logged when the microphone audio volume is below this
+// threshold.
+const int kLowLevelMicrophoneLevelPercent = 10;
 #endif
 }
 
 // Used to log the result of capture startup.
 // This was previously logged as a boolean with only the no callback and OK
 // options. The enum order is kept to ensure backwards compatibility.
 // Elements in this enum should not be deleted or rearranged; the only
 // permitted operation is to add new elements before CAPTURE_STARTUP_RESULT_MAX
 // and update CAPTURE_STARTUP_RESULT_MAX.
 enum CaptureStartupResult {
@@ skipping 444 matching lines @@
         kPowerMonitorLogIntervalSeconds) {
       // Wrap data into an AudioBus to match AudioPowerMonitor::Scan.
       // TODO(henrika): remove this section when capture side uses AudioBus.
       // See http://crbug.com/375155 for details.
       audio_level_->Scan(*source, source->frames());
 
       // Get current average power level and add it to the log.
       // Possible range is given by [-inf, 0] dBFS.
       std::pair<float, bool> result = audio_level_->ReadCurrentPowerAndClip();
 
+      // Add current microphone volume to log and UMA histogram.
+      const int mic_volume_percent = static_cast<int>(100.0 * volume);
+
       // Use event handler on the audio thread to relay a message to the ARIH
       // in content which does the actual logging on the IO thread.
-      task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(
-              &AudioInputController::DoLogAudioLevel, this, result.first));
+      task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&AudioInputController::DoLogAudioLevels,
+                                        this,
+                                        result.first,
+                                        mic_volume_percent));
 
       last_audio_level_log_time_ = base::TimeTicks::Now();
 
       // Reset the average power level (since we don't log continuously).
       audio_level_->Reset();
     }
 #endif
     return;
   }
 
@@ skipping 11 matching lines @@
       base::Bind(
           &AudioInputController::DoOnData, this, base::Passed(&audio_data)));
 }
 
 void AudioInputController::DoOnData(scoped_ptr<AudioBus> data) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (handler_)
     handler_->OnData(this, data.get());
 }
 
-void AudioInputController::DoLogAudioLevel(float level_dbfs) {
+void AudioInputController::DoLogAudioLevels(float level_dbfs,
+                                            int microphone_volume_percent) {
 #if defined(AUDIO_POWER_MONITORING)
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (!handler_)
     return;
 
   std::string log_string = base::StringPrintf(
       "AIC::OnData: average audio level=%.2f dBFS", level_dbfs);
   static const float kSilenceThresholdDBFS = -72.24719896f;
   if (level_dbfs < kSilenceThresholdDBFS)
     log_string += " <=> no audio input!";
   handler_->OnLog(this, log_string);
 
   UpdateSilenceState(level_dbfs < kSilenceThresholdDBFS);
+
+  UMA_HISTOGRAM_PERCENTAGE("Media.MicrophoneVolume", microphone_volume_percent);
+  log_string = base::StringPrintf(
+      "AIC::OnData: microphone volume=%d%%", microphone_volume_percent);
+  if (microphone_volume_percent < kLowLevelMicrophoneLevelPercent)
+    log_string += " <=> low microphone level!";
+  handler_->OnLog(this, log_string);
 #endif
 }
 
 void AudioInputController::OnError(AudioInputStream* stream) {
   // Handle error on the audio-manager thread.
   task_runner_->PostTask(FROM_HERE, base::Bind(
       &AudioInputController::DoReportError, this));
 }
 
 void AudioInputController::DoStopCloseAndClearStream() {
@@ skipping 42 matching lines @@
 }
 
 void AudioInputController::LogSilenceState(SilenceState value) {
   UMA_HISTOGRAM_ENUMERATION("Media.AudioInputControllerSessionSilenceReport",
                             value,
                             SILENCE_STATE_MAX + 1);
 }
 #endif
 
 }  // namespace media