Link things together and enable the device selection for linux and mac.

media/audio/linux/audio_manager_linux.cc

 // Copyright (c) 2011 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"
@@ skipping 18 matching lines @@
 
 // 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",

[scherkus (not reviewing), 2011/11/16 01:20:40]

??

[no longer working on chromium, 2011/11/16 17:45:48]

We would like to strip out all the surround devices like surround4.0,
surround5.0, ..etc.
But for other string like default, we only want to strip default device, but not
device like default-headset.
We have to distinguish two cases.

 };
 
 // Implementation of AudioManager.
 bool AudioManagerLinux::HasAudioOutputDevices() {
   return HasAnyAlsaAudioDevice(kStreamPlayback);
 }
 
 bool AudioManagerLinux::HasAudioInputDevices() {
   return HasAnyAlsaAudioDevice(kStreamCapture);
 }
@@ skipping 30 matching lines @@
     stream = new AlsaPcmOutputStream(device_name, params, wrapper_.get(), this,
                                      GetMessageLoop());
 #if defined(USE_PULSEAUDIO)
   }
 #endif
   active_streams_.insert(stream);
   return stream;
 }
 
 AudioInputStream* AudioManagerLinux::MakeAudioInputStream(
-    const AudioParameters& params) {
+    const AudioParameters& params, const std::string& device_uid) {
   if (!params.IsValid() || params.channels > kMaxInputChannels)
     return NULL;
 
   if (params.format == AudioParameters::AUDIO_MOCK) {
     return FakeAudioInputStream::MakeFakeStream(params);
   } else if (params.format != AudioParameters::AUDIO_PCM_LINEAR) {
     return NULL;
   }
 
   if (!initialized())
     return NULL;
 
-  // TODO(xians): Pass the device name From AudioInputController instead.
-  std::string device_name = AlsaPcmOutputStream::kAutoSelectDevice;
+  std::string device_name;
+  if ((device_uid == AudioManagerBase::kDefaultDeviceId) || device_uid.empty())
+    device_name = AlsaPcmInputStream::kAutoSelectDevice;
+  else
+    device_name = device_uid;
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAlsaInputDevice)) {
     device_name = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kAlsaInputDevice);
   }
 
   AlsaPcmInputStream* stream = new AlsaPcmInputStream(
       device_name, params, wrapper_.get());
 
   return stream;
 }
@@ skipping 61 matching lines @@
   DCHECK(device_names->empty());
 
   GetAlsaAudioInputDevices(device_names);
 
   if (!device_names->empty()) {
     // Prepend the default device to the list since we always want it to be
     // on the top of the list for all platforms. There is no duplicate
     // counting here since the default device has been abstracted out before.
     // We use index 0 to make up the unique_id to identify the default device.
     device_names->push_front(media::AudioDeviceName(
-        AudioManagerBase::kDefaultDeviceName, "0"));
+        AudioManagerBase::kDefaultDeviceName,
+        AudioManagerBase::kDefaultDeviceId));
   }
 }
 
 void AudioManagerLinux::GetAlsaAudioInputDevices(
     media::AudioDeviceNames* device_names) {
   // Constants specified by the ALSA API for device hints.
   static const char kPcmInterfaceName[] = "pcm";
   int card = -1;
 
   // Loop through the sound cards to get ALSA device hints.
@@ skipping 52 matching lines @@
         name.device_name = unique_device_name.get();
       }
 
       // Store the device information.
       device_names->push_back(name);
     }
   }
 }
 
 bool AudioManagerLinux::IsAlsaDeviceAvailable(const char* device_name) {
+  static const char kNotWantedSurroundDevices[] = "surround";
+
   if (!device_name)
     return false;
 
   // Check if the device is in the list of invalid devices.
   for (size_t i = 0; i < arraysize(kInvalidAudioInputDevices); ++i) {
-    if (!strncmp(kInvalidAudioInputDevices[i], device_name,
-                 strlen(kInvalidAudioInputDevices[i])))
+    if (!strcmp(kInvalidAudioInputDevices[i], device_name) ||
+        !strncmp(kNotWantedSurroundDevices, device_name,
+            arraysize(kNotWantedSurroundDevices) -1))

[scherkus (not reviewing), 2011/11/16 01:20:40]

nit space between -1

[no longer working on chromium, 2011/11/16 17:45:48]

Done.

       return false;
   }
 
   // The only way to check if the device is available is to open/close the
   // device. Return false if it fails either of operations.
   snd_pcm_t* device_handle = NULL;
   if (wrapper_->PcmOpen(&device_handle,
                         device_name,
                         SND_PCM_STREAM_CAPTURE,
                         SND_PCM_NONBLOCK))
@@ skipping 41 matching lines @@
     }
   }
 
   return has_device;
 }
 
 // static
 AudioManager* AudioManager::CreateAudioManager() {
   return new AudioManagerLinux();
 }