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.
+    property_address.mScope = is_input ?
+        kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;
+    property_address.mSelector = kAudioDevicePropertyStreamConfiguration;
+    result = AudioObjectGetPropertyDataSize(device_ids[i],
+                                            &property_address,
+                                            0,
+                                            NULL,
+                                            &size);
+    if (result)
+      continue;
+
+    scoped_ptr_malloc<AudioBufferList>
+        buffer(reinterpret_cast<AudioBufferList*>(malloc(size)));
+    AudioBufferList* buffer_list = buffer.get();
+    result = AudioObjectGetPropertyData(device_ids[i],
+                                        &property_address,
+                                        0,
+                                        NULL,
+                                        &size,
+                                        buffer_list);
+    if (result)
+      continue;
+
+    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);
+    property_address.mSelector = kAudioDevicePropertyDeviceUID;
+    property_address.mScope = kAudioObjectPropertyScopeGlobal;
+    result = AudioObjectGetPropertyData(device_ids[i],
+                                        &property_address,
+                                        0,
+                                        NULL,
+                                        &size,
+                                        &uid);
+    if (result)
+      continue;
+
+    // Get device name.
+    CFStringRef name = NULL;
+    property_address.mSelector = kAudioObjectPropertyName;
+    property_address.mScope = kAudioObjectPropertyScopeGlobal;
+    result = AudioObjectGetPropertyData(device_ids[i],
+                                        &property_address,
+                                        0,
+                                        NULL,
+                                        &size,
+                                        &name);
+    if (result) {
+      if (uid)
+        CFRelease(uid);
+      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);
+
+    // We are responsible for releasing the returned CFObject.

[Avi (use Gerrit), 2011/10/27 05:07:14]

Be a little more clear here. "Despite being obtained via a Get function, we are
responsible for releasing the returned CFObjects. See the comment in the xx.h
file for the function xxx for details" or the like. Give me the 'why' rather
than the 'what'.

[no longer working on chromium, 2011/10/28 16:32:37]

Done.

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

[Avi (use Gerrit), 2011/10/27 05:07:14]

space before (

[no longer working on chromium, 2011/10/28 16:32:37]

Done.

+      CFRelease(name);
+  }
+}
+
 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();
 }