Add support for audio input mute detection on all platforms

media/audio/pulse/pulse_input.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/pulse/pulse_input.h"
 
-#include <pulse/pulseaudio.h>
-
 #include "base/logging.h"
 #include "media/audio/pulse/audio_manager_pulse.h"
 #include "media/audio/pulse/pulse_util.h"
 
 namespace media {
 
 using pulse::AutoPulseLock;
 using pulse::WaitForOperationCompletion;
 
 // Number of blocks of buffers used in the |fifo_|.
 const int kNumberOfBlocksBufferInFifo = 2;
 
 PulseAudioInputStream::PulseAudioInputStream(AudioManagerPulse* audio_manager,
                                              const std::string& device_name,
                                              const AudioParameters& params,
                                              pa_threaded_mainloop* mainloop,
                                              pa_context* context)
     : audio_manager_(audio_manager),
       callback_(NULL),
       device_name_(device_name),
       params_(params),
       channels_(0),
       volume_(0.0),
       stream_started_(false),
+      muted_(false),
       fifo_(params.channels(),
             params.frames_per_buffer(),
             kNumberOfBlocksBufferInFifo),
       pa_mainloop_(mainloop),
       pa_context_(context),
       handle_(NULL),
       context_state_changed_(false) {
   DCHECK(mainloop);
   DCHECK(context);
   CHECK(params_.IsValid());
@@ skipping 135 matching lines @@
 
     size_t index = pa_stream_get_device_index(handle_);
     pa_operation* operation = pa_context_get_source_info_by_index(
         pa_context_, index, &VolumeCallback, this);
     // Do not wait for the operation since we can't block the pulse thread.
     pa_operation_unref(operation);
 
     // Return zero and the callback will asynchronously update the |volume_|.
     return 0.0;
   } else {
-    // Called by other thread, put an AutoPulseLock and wait for the operation.
-    AutoPulseLock auto_lock(pa_mainloop_);
-    if (!handle_)
-      return 0.0;
-
-    size_t index = pa_stream_get_device_index(handle_);
-    pa_operation* operation = pa_context_get_source_info_by_index(
-        pa_context_, index, &VolumeCallback, this);
-    WaitForOperationCompletion(pa_mainloop_, operation);
-
+    GetSourceInformation(&VolumeCallback);
     return volume_;
   }
 }
 
+bool PulseAudioInputStream::IsMuted() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  GetSourceInformation(&MuteCallback);
+  return muted_;
+}
+
 // static, used by pa_stream_set_read_callback.
 void PulseAudioInputStream::ReadCallback(pa_stream* handle,
                                          size_t length,
                                          void* user_data) {
   PulseAudioInputStream* stream =
       reinterpret_cast<PulseAudioInputStream*>(user_data);
 
   stream->ReadData();
 }
 
@@ skipping 17 matching lines @@
   for (int i = 0; i < stream->channels_; ++i) {
     if (volume < info->volume.values[i])
       volume = info->volume.values[i];
   }
 
   // It is safe to access |volume_| here since VolumeCallback() is running
   // under PulseLock.
   stream->volume_ = static_cast<double>(volume);
 }
 
+// static, used by pa_context_get_source_info_by_index.
+void PulseAudioInputStream::MuteCallback(pa_context* context,
+                                         const pa_source_info* info,
+                                         int error,
+                                         void* user_data) {
+  // Runs on PulseAudio callback thread. It might be possible to make this
+  // method more thread safe by passing a struct (or pair) of a local copy of
+  // |pa_mainloop_| and |muted_| instead.
+  PulseAudioInputStream* stream =
+      reinterpret_cast<PulseAudioInputStream*>(user_data);
+
+  // Avoid infinite wait loop in case of error.
+  if (error) {
+    pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
+    return;
+  }
+
+  stream->muted_ = info->mute != 0;
+}
+
 // static, used by pa_stream_set_state_callback.
 void PulseAudioInputStream::StreamNotifyCallback(pa_stream* s,
                                                  void* user_data) {
   PulseAudioInputStream* stream =
       reinterpret_cast<PulseAudioInputStream*>(user_data);
+
   if (s && stream->callback_ &&
       pa_stream_get_state(s) == PA_STREAM_FAILED) {
     stream->callback_->OnError(stream);
   }
 
   pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
 }
 
 void PulseAudioInputStream::ReadData() {
   uint32 hardware_delay = pulse::GetHardwareLatencyInBytes(
@@ skipping 40 matching lines @@
 
     // Sleep 5ms to wait until render consumes the data in order to avoid
     // back to back OnData() method.
     if (fifo_.available_blocks())
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(5));
   }
 
   pa_threaded_mainloop_signal(pa_mainloop_, 0);
 }
 
+bool PulseAudioInputStream::GetSourceInformation(pa_source_info_cb_t callback) {
+  AutoPulseLock auto_lock(pa_mainloop_);
+  if (!handle_)
+    return false;
+
+  size_t index = pa_stream_get_device_index(handle_);
+  pa_operation* operation =
+      pa_context_get_source_info_by_index(pa_context_, index, callback, this);
+  WaitForOperationCompletion(pa_mainloop_, operation);
+  return true;
+}
+
 }  // namespace media