Detect AudioInputStream muting and propagate to MediaStreamAudioSource.

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 <inttypes.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/user_input_monitor.h"
 
 namespace media {
 namespace {
 
 const int kMaxInputChannels = 3;
+constexpr int kCheckMutedStateIntervalSeconds = 1;
 
 #if defined(AUDIO_POWER_MONITORING)
 // 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;
 
 // Logs if the user has enabled the microphone mute or not. This is normally
@@ skipping 151 matching lines @@
 #if BUILDFLAG(ENABLE_WEBRTC)
       debug_recording_helper_(params, task_runner_, base::OnceClosure()),
 #endif
       weak_ptr_factory_(this) {
   DCHECK(creator_task_runner_.get());
   DCHECK(handler_);
   DCHECK(sync_writer_);
 }
 
 AudioInputController::~AudioInputController() {
+  DCHECK(!check_muted_state_timer_);
   DCHECK(!audio_callback_);
   DCHECK(!stream_);
 }
 
 // static
 scoped_refptr<AudioInputController> AudioInputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     SyncWriter* sync_writer,
     UserInputMonitor* user_input_monitor,
@@ skipping 136 matching lines @@
   // functionality to modify the input volume slider. One such example is
   // Windows XP.
   power_measurement_is_enabled_ &= agc_is_supported;
 #else
   stream_to_control->SetAutomaticGainControl(enable_agc);
 #endif
 
   // Finally, keep the stream pointer around, update the state and notify.
   stream_ = stream_to_control;
   handler_->OnCreated(this);
+
+  // Check the current muted state and create a new repeating timer to keep that
+  // updated.
+  CheckMutedState();

[DaleCurtis, 2017/06/15 18:44:00]

Instead of using a repeating timer like this why not just check the muted state
during OnData() and post a task to the handler if it's muted? We already do that
for power level checks.

[ossu-chromium, 2017/06/20 12:25:15]

From looking at the implementations of IsMuted, they seem to be making calls
that would result in IPC (not Chrome IPC) and waiting for callbacks. I don't
want to put that kind of code in the audio input callback and risk introducing
latency issues. The call already there only happens once every 15 seconds, which
probably isn't often enough for proper feedback.

Once this chain of CLs has landed, I'd like to have a look at whether these
events could be listened for, instead of polling. If so, I'd be able to get rid
of this timer.

[DaleCurtis, 2017/06/20 17:08:09]

Which implementation are you worried about? I briefly checked the Windows/Mac
ones and they consist of the same type of calls we make elsewhere in the input
drivers.

[ossu-chromium, 2017/06/21 12:51:47]

I'm mostly concerned about the PulseAudio implementation, which does lock the
PulseAudio mainloop, issues an operation and waits for it to complete. I'd guess
that the Mac implementation results in at least one mach ipc call to coreaudiod.
Window seems to be using COM.

It's probably not that much of an issue once every 15 seconds, but I'd like to
avoid it within the callback if at all possible.

+  check_muted_state_timer_.emplace();
+  check_muted_state_timer_->Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kCheckMutedStateIntervalSeconds),
+      this, &AudioInputController::CheckMutedState);
+  DCHECK(check_muted_state_timer_->IsRunning());
 }
 
 void AudioInputController::DoRecord() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime");
 
   if (!stream_ || audio_callback_)
     return;
 
   handler_->OnLog(this, "AIC::DoRecord");
 
   if (user_input_monitor_) {
     user_input_monitor_->EnableKeyPressMonitoring();
     prev_key_down_count_ = user_input_monitor_->GetKeyPressCount();
   }
 
   stream_create_time_ = base::TimeTicks::Now();
 
   audio_callback_.reset(new AudioCallback(this));
   stream_->Start(audio_callback_.get());
 }
 
 void AudioInputController::DoClose() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime");
 
   if (!stream_)
     return;
 
+  // Stop and destroy the muted check timer.
+  check_muted_state_timer_.reset();
+
   // Allow calling unconditionally and bail if we don't have a stream to close.
   if (audio_callback_) {
     stream_->Stop();
 
     // Sometimes a stream (and accompanying audio track) is created and
     // immediately closed or discarded. In this case they are registered as
     // 'stopped early' rather than 'never got data'.
     const base::TimeDelta duration =
         base::TimeTicks::Now() - stream_create_time_;
     CaptureStartupResult capture_startup_result =
@@ skipping 250 matching lines @@
   *mic_volume_percent = static_cast<int>(100.0 * volume);
 
   last_audio_level_log_time_ = now;
 
   return true;
 #else
   return false;
 #endif
 }
 
+void AudioInputController::CheckMutedState() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(stream_);
+  const bool new_state = stream_->IsMuted();
+  if (new_state != is_muted_) {
+    is_muted_ = new_state;
+    // We don't log OnMuted here, but leave that for AudioInputRendererHost.
+    handler_->OnMuted(this, is_muted_);
+  }
+}
+
 // static
 AudioInputController::StreamType AudioInputController::ParamsToStreamType(
     const AudioParameters& params) {
   switch (params.format()) {
     case AudioParameters::Format::AUDIO_PCM_LINEAR:
       return AudioInputController::StreamType::HIGH_LATENCY;
     case AudioParameters::Format::AUDIO_PCM_LOW_LATENCY:
       return AudioInputController::StreamType::LOW_LATENCY;
     default:
       // Currently, the remaining supported type is fake. Reconsider if other
       // formats become supported.
       return AudioInputController::StreamType::FAKE;
   }
 }
 
 }  // namespace media