Only log audio input silence state UMA stats for low latency mode and if not fake device.

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/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
+#include "media/audio/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/scoped_histogram_timer.h"
 #include "media/base/user_input_monitor.h"
 
 using base::TimeDelta;
 
 namespace {
 const int kMaxInputChannels = 3;
 
 // TODO(henrika): remove usage of timers and add support for proper
@@ skipping 57 matching lines @@
                                            UserInputMonitor* user_input_monitor)
     : creator_task_runner_(base::MessageLoopProxy::current()),
       handler_(handler),
       stream_(NULL),
       data_is_active_(false),
       state_(CLOSED),
       sync_writer_(sync_writer),
       max_volume_(0.0),
       user_input_monitor_(user_input_monitor),
 #if defined(AUDIO_POWER_MONITORING)
+      log_silence_state_(false),
       silence_state_(SILENCE_STATE_NO_MEASUREMENT),
 #endif
       prev_key_down_count_(0) {
   DCHECK(creator_task_runner_.get());
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK_EQ(state_, CLOSED);
 }
 
@@ skipping 45 matching lines @@
 
   // Create the AudioInputController object and ensure that it runs on
   // the audio-manager thread.
   scoped_refptr<AudioInputController> controller(
       new AudioInputController(event_handler, sync_writer, user_input_monitor));
   controller->task_runner_ = audio_manager->GetTaskRunner();
 
   // Create and open a new audio input stream from the existing
   // audio-device thread. Use the provided audio-input device.
   if (!controller->task_runner_->PostTask(FROM_HERE,
-          base::Bind(&AudioInputController::DoCreate, controller,
+          base::Bind(&AudioInputController::DoCreateForLowLatency, controller,
                      base::Unretained(audio_manager), params, device_id))) {
     controller = NULL;
   }
 
   return controller;
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::CreateForStream(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
@@ skipping 67 matching lines @@
   silence_state_ = SILENCE_STATE_NO_MEASUREMENT;
 #endif
 
   // TODO(miu): See TODO at top of file.  Until that's resolved, assume all
   // platform audio input requires the |no_data_timer_| be used to auto-detect
   // errors.  In reality, probably only Windows needs to be treated as
   // unreliable here.
   DoCreateForStream(audio_manager->MakeAudioInputStream(params, device_id));
 }
 
+void AudioInputController::DoCreateForLowLatency(AudioManager* audio_manager,

[tommi (sloooow) - chröme, 2014/08/21 18:06:58]

why do we need a new function?  Can't we just add the params.format() check to
DoCreate instead?

[Henrik Grunell, 2014/08/22 08:24:09]

So that it's only logged in the low latency case. I think we want to exclude
e.g. web speech. I don't see a way to tell the difference in DoCreate, it seems
to only be the sync writer that differs in the two CreateXyz functions.

[Henrik Grunell, 2014/08/22 08:51:18]

Ah, now I chatted with Shijing offline and I understand that there's a low
latency mode in the params, which yields 4 combinations (together with
syncwriter or not). I wasn't aware of this before. So it's a bit more
complicated.

I think we should only exclude fake devices then. SG Tommi?

+                                                 const AudioParameters& params,
+                                                 const std::string& device_id) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+#if defined(AUDIO_POWER_MONITORING)
+  // We only log silence state UMA stats for low latency mode and if we use a
+  // real device.
+  if (params.format() != AudioParameters::AUDIO_FAKE)
+    log_silence_state_ = true;
+#endif
+
+  DoCreate(audio_manager, params, device_id);
+}
+
 void AudioInputController::DoCreateForStream(
     AudioInputStream* stream_to_control) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   DCHECK(!stream_);
   stream_ = stream_to_control;
 
   if (!stream_) {
     if (handler_)
       handler_->OnError(this, STREAM_CREATE_ERROR);
@@ skipping 71 matching lines @@
   DoStopCloseAndClearStream();
   SetDataIsActive(false);
 
   if (SharedMemoryAndSyncSocketMode())
     sync_writer_->Close();
 
   if (user_input_monitor_)
     user_input_monitor_->DisableKeyPressMonitoring();
 
 #if defined(AUDIO_POWER_MONITORING)
-  // Send UMA stats if we have enabled power monitoring.
-  if (audio_level_) {
+  // Send UMA stats if enabled.
+  if (log_silence_state_)
     LogSilenceState(silence_state_);
-  }
+  log_silence_state_ = false;
 #endif
 
   state_ = CLOSED;
 }
 
 void AudioInputController::DoReportError() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (handler_)
     handler_->OnError(this, STREAM_ERROR);
 }
@@ skipping 150 matching lines @@
 
 void AudioInputController::DoLogAudioLevel(float level_dbfs) {
 #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) {
+  if (level_dbfs < kSilenceThresholdDBFS)
     log_string += " <=> no audio input!";
-    if (silence_state_ == SILENCE_STATE_NO_MEASUREMENT)
-      silence_state_ = SILENCE_STATE_ONLY_SILENCE;
-    else if (silence_state_ == SILENCE_STATE_ONLY_AUDIO)
-      silence_state_ = SILENCE_STATE_AUDIO_AND_SILENCE;
-    else
-      DCHECK(silence_state_ == SILENCE_STATE_ONLY_SILENCE ||
-             silence_state_ == SILENCE_STATE_AUDIO_AND_SILENCE);
-  } else {
-    if (silence_state_ == SILENCE_STATE_NO_MEASUREMENT)
-      silence_state_ = SILENCE_STATE_ONLY_AUDIO;
-    else if (silence_state_ == SILENCE_STATE_ONLY_SILENCE)
-      silence_state_ = SILENCE_STATE_AUDIO_AND_SILENCE;
-    else
-      DCHECK(silence_state_ == SILENCE_STATE_ONLY_AUDIO ||
-             silence_state_ == SILENCE_STATE_AUDIO_AND_SILENCE);
-  }
+  handler_->OnLog(this, log_string);
 
-  handler_->OnLog(this, log_string);
+  UpdateSilenceState(level_dbfs < kSilenceThresholdDBFS);
 #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 12 matching lines @@
 
 void AudioInputController::SetDataIsActive(bool enabled) {
   base::subtle::Release_Store(&data_is_active_, enabled);
 }
 
 bool AudioInputController::GetDataIsActive() {
   return (base::subtle::Acquire_Load(&data_is_active_) != false);
 }
 
 #if defined(AUDIO_POWER_MONITORING)
+void AudioInputController::UpdateSilenceState(bool silence) {
+  if (silence) {
+    if (silence_state_ == SILENCE_STATE_NO_MEASUREMENT)
+      silence_state_ = SILENCE_STATE_ONLY_SILENCE;
+    else if (silence_state_ == SILENCE_STATE_ONLY_AUDIO)
+      silence_state_ = SILENCE_STATE_AUDIO_AND_SILENCE;
+    else
+      DCHECK(silence_state_ == SILENCE_STATE_ONLY_SILENCE ||

[tommi (sloooow) - chröme, 2014/08/21 18:06:58]

{} (and subsequently add {} to all cases)

[Henrik Grunell, 2014/08/22 08:24:09]

Done.

+             silence_state_ == SILENCE_STATE_AUDIO_AND_SILENCE);
+  } else {
+    if (silence_state_ == SILENCE_STATE_NO_MEASUREMENT)
+      silence_state_ = SILENCE_STATE_ONLY_AUDIO;
+    else if (silence_state_ == SILENCE_STATE_ONLY_SILENCE)
+      silence_state_ = SILENCE_STATE_AUDIO_AND_SILENCE;
+    else
+      DCHECK(silence_state_ == SILENCE_STATE_ONLY_AUDIO ||
+             silence_state_ == SILENCE_STATE_AUDIO_AND_SILENCE);
+  }
+}
+
 void AudioInputController::LogSilenceState(SilenceState value) {
   UMA_HISTOGRAM_ENUMERATION("Media.AudioInputControllerSessionSilenceReport",
                             value,
                             SILENCE_STATE_MAX + 1);
 }
 #endif
 
 }  // namespace media