Implement GetDefaultOutputDeviceID, GetAssociatedOutputDeviceID and ...

media/audio/mac/audio_manager_mac.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/mac/audio_manager_mac.h"
 
 #include <CoreAudio/AudioHardware.h>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 168 matching lines @@
                                            const std::string& device_id) {
   AudioObjectPropertyAddress property_address = {
     kAudioHardwarePropertyDevices,
     kAudioObjectPropertyScopeGlobal,
     kAudioObjectPropertyElementMaster
   };
   AudioDeviceID audio_device_id = kAudioObjectUnknown;
   UInt32 device_size = sizeof(audio_device_id);
   OSStatus result = -1;
 
-  if (device_id == AudioManagerBase::kDefaultDeviceId) {
+  if (device_id == AudioManagerBase::kDefaultDeviceId || device_id.empty()) {
     // Default Device.
     property_address.mSelector = is_input ?
         kAudioHardwarePropertyDefaultInputDevice :
         kAudioHardwarePropertyDefaultOutputDevice;
 
     result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                         &property_address,
                                         0,
                                         0,
                                         &device_size,
@@ skipping 234 matching lines @@
   int sample_rate = HardwareSampleRateForDevice(device);
   if (!sample_rate)
     sample_rate = kFallbackSampleRate;
 
   // TODO(xians): query the native channel layout for the specific device.
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
       sample_rate, 16, buffer_size);
 }
 
+std::string AudioManagerMac::GetAssociatedOutputDeviceID(
+    const std::string& input_device_id) {
+  AudioDeviceID device = GetAudioDeviceIdByUId(true, input_device_id);
+  if (device == kAudioObjectUnknown)
+    return std::string();
+
+  UInt32 size = 0;
+  AudioObjectPropertyAddress pa = {
+    kAudioDevicePropertyRelatedDevices,

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

Guess thus guy is the key here. Nice.

+    kAudioObjectPropertyScopeOutput,
+    kAudioObjectPropertyElementMaster
+  };
+  OSStatus result = AudioObjectGetPropertyDataSize(device, &pa, 0, 0, &size);
+  if (result || !size)
+    return std::string();
+
+  int device_count = size / sizeof(AudioDeviceID);
+  scoped_ptr_malloc<AudioDeviceID>
+      devices(reinterpret_cast<AudioDeviceID*>(malloc(size)));

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

I always hesitate to use reinterpret; you don't ;-)

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

Not when it's the right thing to do ;)

+  result = AudioObjectGetPropertyData(
+      device, &pa, 0, NULL, &size, devices.get());
+  if (result)
+    return std::string();
+
+  for (int i = 0; i < device_count; ++i) {
+    // Get the number of  output channels of the device.
+    pa.mSelector = kAudioDevicePropertyStreams;
+    size = 0;
+    result = AudioObjectGetPropertyDataSize(devices.get()[i],

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

Nit, I did clang-format on my latest CL and I think it lines up params in an
alternative way. You could try it with git cl format if you like. Guess it will
be mandatory soon in Chrome anyhow.

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

This is fine style-wize and consistent with all other call sites of
AudioObjectGetPropertyDataSize in this file.

+                                            &pa,
+                                            0,
+                                            NULL,
+                                            &size);
+    if (result || !size)
+      continue;  // Skip if there aren't any output channels.

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

Don't we have methods to detect number of output devices which can be utilized
at the top of this function to ensure that we don't even try if there are no
outputs?

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

See line 453 where the "scope" is set to output.
When we hit this line, the outputs of the matched device aren't active.

+
+    // Get device UID.
+    CFStringRef uid = NULL;
+    size = sizeof(uid);
+    pa.mSelector = kAudioDevicePropertyDeviceUID;
+    result = AudioObjectGetPropertyData(devices.get()[i],
+                                        &pa,
+                                        0,
+                                        NULL,
+                                        &size,
+                                        &uid);
+    if (result || !uid)
+      continue;
+
+    std::string ret(base::SysCFStringRefToUTF8(uid));

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

What does these IDs look like?

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

Here's an example of a USB device I tested with:
input: AppleUSBAudioEngine:Fractal Audio Systems:AXE-FX II:1a120000:2,1
output: AppleUSBAudioEngine:Fractal Audio Systems:AXE-FX II:1a120000:2,1

+    CFRelease(uid);
+    return ret;
+  }
+
+  // No matching device found.
+  return std::string();
+}
+
 AudioOutputStream* AudioManagerMac::MakeLinearOutputStream(
     const AudioParameters& params) {
   return MakeLowLatencyOutputStream(params, std::string(), std::string());
 }
 
 AudioOutputStream* AudioManagerMac::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const std::string& input_device_id) {
   DLOG_IF(ERROR, !device_id.empty()) << "Not implemented!";
@@ skipping 46 matching lines @@
   AudioDeviceID audio_device_id = GetAudioDeviceIdByUId(true, input_device_id);
   if (audio_device_id == kAudioObjectUnknown)
     return NULL;
 
   return new AudioSynchronizedStream(this,
                                      params,
                                      audio_device_id,
                                      kAudioDeviceUnknown);
 }
 
+std::string AudioManagerMac::GetDefaultOutputDeviceID() {
+  AudioDeviceID device_id = kAudioObjectUnknown;
+  if (!GetDefaultOutputDevice(&device_id))
+    return std::string();
+
+  const AudioObjectPropertyAddress property_address = {
+    kAudioDevicePropertyDeviceUID,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+  CFStringRef device_uid = NULL;
+  UInt32 size = sizeof(device_uid);
+  OSStatus status = AudioObjectGetPropertyData(device_id, &property_address, 0,

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

Different style than above ;-)

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

Fixed.

+      NULL, &size, &device_uid);
+  if (status != kAudioHardwareNoError || !device_uid)
+    return std::string();
+
+  std::string ret(base::SysCFStringRefToUTF8(device_uid));
+  CFRelease(device_uid);
+
+  return ret;
+}
+
 AudioInputStream* AudioManagerMac::MakeLinearInputStream(
     const AudioParameters& params, const std::string& device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   return new PCMQueueInAudioInputStream(this, params);
 }
 
 AudioInputStream* AudioManagerMac::MakeLowLatencyInputStream(
     const AudioParameters& params, const std::string& device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   // Gets the AudioDeviceID that refers to the AudioOutputDevice with the device
   // unique id. This AudioDeviceID is used to set the device for Audio Unit.
   AudioDeviceID audio_device_id = GetAudioDeviceIdByUId(true, device_id);
   AudioInputStream* stream = NULL;
   if (audio_device_id != kAudioObjectUnknown)
     stream = new AUAudioInputStream(this, params, audio_device_id);
 
   return stream;
 }
 
 AudioParameters AudioManagerMac::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
-  // TODO(tommi): Support |output_device_id|.
-  DLOG_IF(ERROR, !output_device_id.empty()) << "Not implemented!";
+  AudioDeviceID device = GetAudioDeviceIdByUId(true, output_device_id);
+  if (device == kAudioObjectUnknown) {
+    DLOG(ERROR) << "Invalid device " << output_device_id;

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

I would say Invalid output device just in case

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

Done.

+    return AudioParameters();
+  }
+
   int hardware_channels = 2;

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

Don't understand this "fallback" scheme. Do you?

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

Not really.  I guess there must be a case where we fail to get the stream
configuration but the rest works regardless?

-  if (!GetDefaultOutputChannels(&hardware_channels)) {
+  if (!GetDeviceChannels(device, kAudioDevicePropertyScopeOutput,
+                         &hardware_channels)) {
     // Fallback to stereo.
     hardware_channels = 2;
   }
 
   ChannelLayout channel_layout = GuessChannelLayout(hardware_channels);
 
-  const int hardware_sample_rate = AUAudioOutputStream::HardwareSampleRate();
+  const int hardware_sample_rate = HardwareSampleRateForDevice(device);
   const int buffer_size = ChooseBufferSize(hardware_sample_rate);
 
   int input_channels = 0;
   if (input_params.IsValid()) {
     input_channels = input_params.input_channels();
 
     if (input_channels > 0) {
       // TODO(crogers): given the limitations of the AudioOutputStream

[henrika (OOO until Aug 14), 2013/09/07 08:04:25]

Change crogers to xians?

[tommi (sloooow) - chröme, 2013/09/08 19:11:19]

Done.

       // back-ends used with synchronized I/O, we hard-code to stereo.
       // Specifically, this is a limitation of AudioSynchronizedStream which
       // can be removed as part of the work to consolidate these back-ends.
       channel_layout = CHANNEL_LAYOUT_STEREO;
     }
   }
 
   AudioParameters params(
       AudioParameters::AUDIO_PCM_LOW_LATENCY,
       channel_layout,
@@ skipping 44 matching lines @@
   current_sample_rate_ = new_sample_rate;
   current_output_device_ = new_output_device;
   NotifyAllOutputDeviceChangeListeners();
 }
 
 AudioManager* CreateAudioManager() {
   return new AudioManagerMac();
 }
 
 }  // namespace media