Adding pulseaudio input support to chrome

media/audio/linux/audio_manager_linux.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/linux/audio_manager_linux.h"
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/nix/xdg_util.h"
 #include "base/process_util.h"
 #include "base/stl_util.h"
 #include "media/audio/audio_output_dispatcher.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/linux/alsa_input.h"
 #include "media/audio/linux/alsa_output.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #if defined(USE_PULSEAUDIO)
-#include "media/audio/pulse/pulse_output.h"
+#include "media/audio/pulse/audio_manager_pulse.h"
 #endif
 #if defined(USE_CRAS)
 #include "media/audio/linux/cras_input.h"
 #include "media/audio/linux/cras_output.h"
 #endif
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 
 namespace media {
 
 // Maximum number of output streams that can be open simultaneously.
 static const int kMaxOutputStreams = 50;
 
 // Since "default", "pulse" and "dmix" devices are virtual devices mapped to
 // real devices, we remove them from the list to avoiding duplicate counting.
 // In addition, note that we support no more than 2 channels for recording,
 // hence surround devices are not stored in the list.
 static const char* kInvalidAudioInputDevices[] = {
   "default",
   "null",
   "pulse",
   "dmix",
   "surround",
 };
 
 static const char kCrasAutomaticDeviceName[] = "Automatic";
 static const char kCrasAutomaticDeviceId[] = "automatic";
 
+// static
+void AudioManagerLinux::ShowLinuxAudioInputSettings() {
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  CommandLine command_line(CommandLine::NO_PROGRAM);
+  switch (base::nix::GetDesktopEnvironment(env.get())) {
+    case base::nix::DESKTOP_ENVIRONMENT_GNOME:
+      command_line.SetProgram(base::FilePath("gnome-volume-control"));
+      break;
+    case base::nix::DESKTOP_ENVIRONMENT_KDE3:
+    case base::nix::DESKTOP_ENVIRONMENT_KDE4:
+      command_line.SetProgram(base::FilePath("kmix"));
+      break;
+    case base::nix::DESKTOP_ENVIRONMENT_UNITY:
+      command_line.SetProgram(base::FilePath("gnome-control-center"));
+      command_line.AppendArg("sound");
+      command_line.AppendArg("input");
+      break;
+    default:
+      LOG(ERROR) << "Failed to show audio input settings: we don't know "
+                 << "what command to use for your desktop environment.";
+      return;
+  }
+  base::LaunchProcess(command_line, base::LaunchOptions(), NULL);
+}
+
 // Implementation of AudioManager.
 bool AudioManagerLinux::HasAudioOutputDevices() {
   if (UseCras())
     return true;
 
   return HasAnyAlsaAudioDevice(kStreamPlayback);
 }
 
 bool AudioManagerLinux::HasAudioInputDevices() {
   if (UseCras())
     return true;
 
   return HasAnyAlsaAudioDevice(kStreamCapture);
 }
 
 AudioManagerLinux::AudioManagerLinux()
     : wrapper_(new AlsaWrapper()) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 }
 
 AudioManagerLinux::~AudioManagerLinux() {
   Shutdown();
 }
 
 void AudioManagerLinux::ShowAudioInputSettings() {
-  scoped_ptr<base::Environment> env(base::Environment::Create());
-  CommandLine command_line(CommandLine::NO_PROGRAM);
-  switch (base::nix::GetDesktopEnvironment(env.get())) {
-    case base::nix::DESKTOP_ENVIRONMENT_GNOME:
-      command_line.SetProgram(base::FilePath("gnome-volume-control"));
-      break;
-    case base::nix::DESKTOP_ENVIRONMENT_KDE3:
-    case base::nix::DESKTOP_ENVIRONMENT_KDE4:
-      command_line.SetProgram(base::FilePath("kmix"));
-      break;
-    case base::nix::DESKTOP_ENVIRONMENT_UNITY:
-      command_line.SetProgram(base::FilePath("gnome-control-center"));
-      command_line.AppendArg("sound");
-      command_line.AppendArg("input");
-      break;
-    default:
-      LOG(ERROR) << "Failed to show audio input settings: we don't know "
-                 << "what command to use for your desktop environment.";
-      return;
-  }
-  base::LaunchProcess(command_line, base::LaunchOptions(), NULL);
+  ShowLinuxAudioInputSettings();
 }
 
 void AudioManagerLinux::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
   if (UseCras()) {
     GetCrasAudioInputDevices(device_names);
     return;
   }
 
@@ skipping 174 matching lines @@
 }
 
 AudioOutputStream* AudioManagerLinux::MakeOutputStream(
     const AudioParameters& params) {
 #if defined(USE_CRAS)
   if (UseCras()) {
     return new CrasOutputStream(params, this);
   }
 #endif
 
-#if defined(USE_PULSEAUDIO)
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUsePulseAudio)) {
-    return new PulseAudioOutputStream(params, this);
-  }
-#endif
-
   std::string device_name = AlsaPcmOutputStream::kAutoSelectDevice;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAlsaOutputDevice)) {
     device_name = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kAlsaOutputDevice);
   }
   return new AlsaPcmOutputStream(device_name, params, wrapper_.get(), this);
 }
 
 AudioInputStream* AudioManagerLinux::MakeInputStream(
     const AudioParameters& params, const std::string& device_id) {
 #if defined(USE_CRAS)
   if (UseCras()) {
     return new CrasInputStream(params, this);
   }
 #endif
 
   std::string device_name = (device_id == AudioManagerBase::kDefaultDeviceId) ?
       AlsaPcmInputStream::kAutoSelectDevice : device_id;
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAlsaInputDevice)) {
     device_name = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kAlsaInputDevice);
   }
 
   return new AlsaPcmInputStream(this, device_name, params, wrapper_.get());
 }
 
 AudioManager* CreateAudioManager() {
+#if defined(USE_PULSEAUDIO)
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kUsePulseAudio)) {
+    AudioManager* manager = AudioManagerPulse::Create();
+    if (manager)
+      return manager;
+  }
+#endif
+
   return new AudioManagerLinux();
 }
 
 AudioParameters AudioManagerLinux::GetPreferredLowLatencyOutputStreamParameters(
     const AudioParameters& input_params) {
   // Since Linux doesn't actually have a low latency path the hardware buffer
   // size is quite large in order to prevent glitches with general usage.  Some
   // clients, such as WebRTC, have a more limited use case and work acceptably
   // with a smaller buffer size.  The check below allows clients which want to
   // try a smaller buffer size on Linux to do so.
   int buffer_size = GetAudioHardwareBufferSize();
   if (input_params.frames_per_buffer() < buffer_size)
     buffer_size = input_params.frames_per_buffer();
 
   // TODO(dalecurtis): This should include bits per channel and channel layout
   // eventually.
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, input_params.channel_layout(),
       input_params.sample_rate(), 16, buffer_size);
 }
 
 }  // namespace media