This patch will loop through the soundcard and return a list of available devices when the AudioI...

media/audio/mac/audio_manager_mac.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 <CoreAudio/AudioHardware.h>
 
 #include "base/mac/mac_util.h"
+#include "base/sys_string_conversions.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/audio/mac/audio_input_mac.h"
 #include "media/audio/mac/audio_low_latency_input_mac.h"
 #include "media/audio/mac/audio_low_latency_output_mac.h"
 #include "media/audio/mac/audio_manager_mac.h"
 #include "media/audio/mac/audio_output_mac.h"
 #include "media/base/limits.h"
 
 static const int kMaxInputChannels = 2;
@@ skipping 40 matching lines @@
   OSStatus err = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                             &property_address,
                                             0,     // inQualifierDataSize
                                             NULL,  // inQualifierData
                                             &output_device_id_size,
                                             &output_device_id);
   return err == kAudioHardwareNoError &&
       output_device_id != kAudioObjectUnknown;
 }
 
+static void GetAudioDeviceInfo(bool is_input,
+                               media::AudioDeviceNames* device_names) {
+  DCHECK(device_names);
+  device_names->clear();
+
+  // Query the number of total devices.
+  AudioObjectPropertyAddress property_address = {
+    kAudioHardwarePropertyDevices,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+  UInt32 size = 0;
+  OSStatus result = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject,
+                                                   &property_address,
+                                                   0,
+                                                   NULL,
+                                                   &size);
+  if (result || !size)
+    return;
+
+  int device_count = size / sizeof(AudioDeviceID);
+
+  // Get the array of device ids for all the devices, which includes both
+  // input devices and output devices.
+  scoped_ptr_malloc<AudioDeviceID>
+      devices(reinterpret_cast<AudioDeviceID*>(malloc(size)));
+  AudioDeviceID* device_ids = devices.get();
+  result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                      &property_address,
+                                      0,
+                                      NULL,
+                                      &size,
+                                      device_ids);
+  if (result)
+    return;
+
+  // Iterate over all available devices to gather information.
+  for (int i = 0; i < device_count; ++i) {
+    int channels = 0;
+    // Get the number of input or output channels of the device.
+    AudioDeviceGetPropertyInfo(device_ids[i],

[Avi (use Gerrit), 2011/10/26 21:44:25]

obsolete

+                               0,
+                               is_input,
+                               kAudioDevicePropertyStreamConfiguration,
+                               &size,
+                               NULL);
+    scoped_ptr_malloc<AudioBufferList>
+        buffer(reinterpret_cast<AudioBufferList*>(malloc(size)));
+    AudioBufferList* buffer_list = buffer.get();
+    AudioDeviceGetProperty(device_ids[i],

[Avi (use Gerrit), 2011/10/26 21:44:25]

obsolete

+                           0,
+                           is_input,
+                           kAudioDevicePropertyStreamConfiguration,
+                           &size,
+                           buffer_list);
+
+    for (uint32 j = 0; j < buffer_list->mNumberBuffers; ++j)
+      channels += buffer_list->mBuffers[j].mNumberChannels;
+
+    // Exclude those devices without the type of channel we are interested in.
+    if (!channels)
+      continue;
+
+    // Get device UID.
+    CFStringRef uid = NULL;
+    size = sizeof(uid);
+    result = AudioDeviceGetProperty(device_ids[i],

[Avi (use Gerrit), 2011/10/26 21:44:25]

AudioDeviceGetProperty is deprecated (see TN2223), and the replacement,
AudioObjectGetPropertyData, is available in 10.5. Please switch.

+                                    0,
+                                    is_input,
+                                    kAudioDevicePropertyDeviceUID,
+                                    &size,
+                                    &uid);
+    if (result)
+      continue;
+
+    // Get device name.
+    CFStringRef name = NULL;
+    result = AudioDeviceGetProperty(device_ids[i],

[Avi (use Gerrit), 2011/10/26 21:44:25]

obsolete

+                                    0,
+                                    is_input,
+                                    kAudioObjectPropertyName,
+                                    &size,
+                                    &name);
+    if (result)
+      continue;
+
+    // Store the device name and UID.
+    media::AudioDeviceName device_name;
+    device_name.device_name = base::SysCFStringRefToUTF8(name);
+    device_name.unique_id = base::SysCFStringRefToUTF8(uid);
+    device_names->push_back(device_name);
+  }

[Chris Rogers, 2011/10/26 18:52:44]

I believe you have a memory leak here, since you need to release the two
CFString objects:

if (uid)
  CFRelease(uid);
if (name)
  CFRelease(name);

[no longer working on chromium, 2011/10/26 21:33:09]

Thanks, you are right, there is a leak there. It failed the mac_valgrind trybot.
Now it is fixed. I will re-run the trybot to make sure.

[Avi (use Gerrit), 2011/10/26 21:44:25]

I'm a little confused on why. Does AudioDeviceGetProperty return a referenced
object? Where is that documented?

[Chris Rogers, 2011/10/26 21:49:44]

It's documented in AudioHardware.h in the discussion about the individual
properties:

"The caller is responsible for releasing the returned CFObject."

On 2011/10/26 21:44:25, Avi wrote:

+}
+
 AudioManagerMac::AudioManagerMac()
     : num_output_streams_(0) {
 }
 
 AudioManagerMac::~AudioManagerMac() {
 }
 
 bool AudioManagerMac::HasAudioOutputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultOutputDevice);
 }
 
 bool AudioManagerMac::HasAudioInputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultInputDevice);
 }
 
 void AudioManagerMac::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
-  // TODO(xians): query a full list of valid devices.
-  if (HasAudioInputDevices()) {
-    // Add the default device to the list.
-    // We use index 0 to make up the unique_id to identify the
-    // default devices.
+  GetAudioDeviceInfo(true, 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.
     media::AudioDeviceName name;
     name.device_name = AudioManagerBase::kDefaultDeviceName;
     name.unique_id = "0";
-    device_names->push_back(name);
+    device_names->push_front(name);
   }
 }
 
 AudioOutputStream* AudioManagerMac::MakeAudioOutputStream(
     const AudioParameters& params) {
   if (!params.IsValid())
     return NULL;
 
   // Limit the number of audio streams opened. This is to prevent using
   // excessive resources for a large number of audio streams. More
@@ skipping 47 matching lines @@
 
 // Called by the stream when it has been released by calling Close().
 void AudioManagerMac::ReleaseInputStream(AudioInputStream* stream) {
   delete stream;
 }
 
 // static
 AudioManager* AudioManager::CreateAudioManager() {
   return new AudioManagerMac();
 }