media/audio/mac/aggregate_device_manager.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/audio/mac/aggregate_device_manager.h"
   6
   7 #include <CoreAudio/AudioHardware.h>
   8 #include <string>
   9
  10 #include "base/mac/mac_logging.h"
  11 #include "base/mac/scoped_cftyperef.h"
  12 #include "media/audio/audio_parameters.h"
  13 #include "media/audio/mac/audio_manager_mac.h"
  14
  15 using base::ScopedCFTypeRef;
  16
  17 namespace media {
  18
  19 AggregateDeviceManager::AggregateDeviceManager()
  20     : plugin_id_(kAudioObjectUnknown),
  21       input_device_(kAudioDeviceUnknown),
  22       output_device_(kAudioDeviceUnknown),
  23       aggregate_device_(kAudioObjectUnknown) {
  24 }
  25
  26 AggregateDeviceManager::~AggregateDeviceManager() {
  27   DestroyAggregateDevice();
  28 }
  29
  30 AudioDeviceID AggregateDeviceManager::GetDefaultAggregateDevice() {
  31   AudioDeviceID current_input_device;
  32   AudioDeviceID current_output_device;
  33   AudioManagerMac::GetDefaultInputDevice(&current_input_device);
  34   AudioManagerMac::GetDefaultOutputDevice(&current_output_device);
  35
  36   if (AudioManagerMac::HardwareSampleRateForDevice(current_input_device) !=
  37       AudioManagerMac::HardwareSampleRateForDevice(current_output_device)) {
  38     // TODO(crogers): with some extra work we can make aggregate devices work
  39     // if the clock domain is the same but the sample-rate differ.
  40     // For now we fallback to the synchronized path.
  41     return kAudioDeviceUnknown;
  42   }
  43
  44   // Use a lazily created aggregate device if it's already available
  45   // and still appropriate.
  46   if (aggregate_device_ != kAudioObjectUnknown) {
  47     // TODO(crogers): handle default device changes for synchronized I/O.
  48     // For now, we check to make sure the default devices haven't changed
  49     // since we lazily created the aggregate device.
  50     if (current_input_device == input_device_ &&
  51         current_output_device == output_device_)
  52       return aggregate_device_;
  53
  54     // For now, once lazily created don't attempt to create another
  55     // aggregate device.
  56     return kAudioDeviceUnknown;
  57   }
  58
  59   input_device_ = current_input_device;
  60   output_device_ = current_output_device;
  61
  62   // Only create an aggregrate device if the clock domains match.
  63   UInt32 input_clockdomain = GetClockDomain(input_device_);
  64   UInt32 output_clockdomain = GetClockDomain(output_device_);
  65   DVLOG(1) << "input_clockdomain: " << input_clockdomain;
  66   DVLOG(1) << "output_clockdomain: " << output_clockdomain;
  67
  68   if (input_clockdomain == 0 || input_clockdomain != output_clockdomain)
  69     return kAudioDeviceUnknown;
  70
  71   OSStatus result = CreateAggregateDevice(
  72       input_device_,
  73       output_device_,
  74       &aggregate_device_);
  75   if (result != noErr)
  76     DestroyAggregateDevice();
  77
  78   return aggregate_device_;
  79 }
  80
  81 CFStringRef AggregateDeviceManager::GetDeviceUID(AudioDeviceID id) {
  82   static const AudioObjectPropertyAddress kDeviceUIDAddress = {
  83     kAudioDevicePropertyDeviceUID,
  84     kAudioObjectPropertyScopeGlobal,
  85     kAudioObjectPropertyElementMaster
  86   };
  87
  88   // As stated in the CoreAudio header (AudioHardwareBase.h),
  89   // the caller is responsible for releasing the device_UID.
  90   CFStringRef device_UID;
  91   UInt32 size = sizeof(device_UID);
  92   OSStatus result = AudioObjectGetPropertyData(
  93       id,
  94       &kDeviceUIDAddress,
  95       0,
  96       0,
  97       &size,
  98       &device_UID);
  99
 100   return (result == noErr) ? device_UID : NULL;
 101 }
 102
 103 void AggregateDeviceManager::GetDeviceName(
 104     AudioDeviceID id, char* name, UInt32 size) {
 105   static const AudioObjectPropertyAddress kDeviceNameAddress = {
 106     kAudioDevicePropertyDeviceName,
 107     kAudioObjectPropertyScopeGlobal,
 108     kAudioObjectPropertyElementMaster
 109   };
 110
 111   OSStatus result = AudioObjectGetPropertyData(
 112       id,
 113       &kDeviceNameAddress,
 114       0,
 115       0,
 116       &size,
 117       name);
 118
 119   if (result != noErr && size > 0)
 120     name[0] = 0;
 121 }
 122
 123 UInt32 AggregateDeviceManager::GetClockDomain(AudioDeviceID device_id) {
 124   static const AudioObjectPropertyAddress kClockDomainAddress = {
 125     kAudioDevicePropertyClockDomain,
 126     kAudioObjectPropertyScopeGlobal,
 127     kAudioObjectPropertyElementMaster
 128   };
 129
 130   UInt32 clockdomain = 0;
 131   UInt32 size = sizeof(UInt32);
 132   OSStatus result = AudioObjectGetPropertyData(
 133       device_id,
 134       &kClockDomainAddress,
 135       0,
 136       0,
 137       &size,
 138       &clockdomain);
 139
 140   return (result == noErr) ? clockdomain : 0;
 141 }
 142
 143 OSStatus AggregateDeviceManager::GetPluginID(AudioObjectID* id) {
 144   DCHECK(id);
 145
 146   // Get the audio hardware plugin.
 147   CFStringRef bundle_name = CFSTR("com.apple.audio.CoreAudio");
 148
 149   AudioValueTranslation plugin_translation;
 150   plugin_translation.mInputData = &bundle_name;
 151   plugin_translation.mInputDataSize = sizeof(bundle_name);
 152   plugin_translation.mOutputData = id;
 153   plugin_translation.mOutputDataSize = sizeof(*id);
 154
 155   static const AudioObjectPropertyAddress kPlugInAddress = {
 156     kAudioHardwarePropertyPlugInForBundleID,
 157     kAudioObjectPropertyScopeGlobal,
 158     kAudioObjectPropertyElementMaster
 159   };
 160
 161   UInt32 size = sizeof(plugin_translation);
 162   OSStatus result = AudioObjectGetPropertyData(
 163       kAudioObjectSystemObject,
 164       &kPlugInAddress,
 165       0,
 166       0,
 167       &size,
 168       &plugin_translation);
 169
 170   DVLOG(1) << "CoreAudio plugin ID: " << *id;
 171
 172   return result;
 173 }
 174
 175 CFMutableDictionaryRef
 176 AggregateDeviceManager::CreateAggregateDeviceDictionary(
 177     AudioDeviceID input_id,
 178     AudioDeviceID output_id) {
 179   CFMutableDictionaryRef aggregate_device_dict = CFDictionaryCreateMutable(
 180       NULL,
 181       0,
 182       &kCFTypeDictionaryKeyCallBacks,
 183       &kCFTypeDictionaryValueCallBacks);
 184   if (!aggregate_device_dict)
 185     return NULL;
 186
 187   const CFStringRef kAggregateDeviceName =
 188       CFSTR("ChromeAggregateAudioDevice");
 189   const CFStringRef kAggregateDeviceUID =
 190       CFSTR("com.google.chrome.AggregateAudioDevice");
 191
 192   // Add name and UID of the device to the dictionary.
 193   CFDictionaryAddValue(
 194       aggregate_device_dict,
 195       CFSTR(kAudioAggregateDeviceNameKey),
 196       kAggregateDeviceName);
 197   CFDictionaryAddValue(
 198       aggregate_device_dict,
 199       CFSTR(kAudioAggregateDeviceUIDKey),
 200       kAggregateDeviceUID);
 201
 202   // Add a "private aggregate key" to the dictionary.
 203   // The 1 value means that the created aggregate device will
 204   // only be accessible from the process that created it, and
 205   // won't be visible to outside processes.
 206   int value = 1;
 207   ScopedCFTypeRef<CFNumberRef> aggregate_device_number(CFNumberCreate(
 208       NULL,
 209       kCFNumberIntType,
 210       &value));
 211   CFDictionaryAddValue(
 212       aggregate_device_dict,
 213       CFSTR(kAudioAggregateDeviceIsPrivateKey),
 214       aggregate_device_number);
 215
 216   return aggregate_device_dict;
 217 }
 218
 219 CFMutableArrayRef
 220 AggregateDeviceManager::CreateSubDeviceArray(
 221     CFStringRef input_device_UID, CFStringRef output_device_UID) {
 222   CFMutableArrayRef sub_devices_array = CFArrayCreateMutable(
 223       NULL,
 224       0,
 225       &kCFTypeArrayCallBacks);
 226
 227   CFArrayAppendValue(sub_devices_array, input_device_UID);
 228   CFArrayAppendValue(sub_devices_array, output_device_UID);
 229
 230   return sub_devices_array;
 231 }
 232
 233 OSStatus AggregateDeviceManager::CreateAggregateDevice(
 234     AudioDeviceID input_id,
 235     AudioDeviceID output_id,
 236     AudioDeviceID* aggregate_device) {
 237   DCHECK(aggregate_device);
 238
 239   const size_t kMaxDeviceNameLength = 256;
 240
 241   scoped_ptr<char[]> input_device_name(new char[kMaxDeviceNameLength]);
 242   GetDeviceName(
 243       input_id,
 244       input_device_name.get(),
 245       sizeof(input_device_name));
 246   DVLOG(1) << "Input device: \n" << input_device_name;
 247
 248   scoped_ptr<char[]> output_device_name(new char[kMaxDeviceNameLength]);
 249   GetDeviceName(
 250       output_id,
 251       output_device_name.get(),
 252       sizeof(output_device_name));
 253   DVLOG(1) << "Output device: \n" << output_device_name;
 254
 255   OSStatus result = GetPluginID(&plugin_id_);
 256   if (result != noErr)
 257     return result;
 258
 259   // Create a dictionary for the aggregate device.
 260   ScopedCFTypeRef<CFMutableDictionaryRef> aggregate_device_dict(
 261       CreateAggregateDeviceDictionary(input_id, output_id));
 262   if (!aggregate_device_dict)
 263     return -1;
 264
 265   // Create the aggregate device.
 266   static const AudioObjectPropertyAddress kCreateAggregateDeviceAddress = {
 267     kAudioPlugInCreateAggregateDevice,
 268     kAudioObjectPropertyScopeGlobal,
 269     kAudioObjectPropertyElementMaster
 270   };
 271
 272   UInt32 size = sizeof(*aggregate_device);
 273   result = AudioObjectGetPropertyData(
 274       plugin_id_,
 275       &kCreateAggregateDeviceAddress,
 276       sizeof(aggregate_device_dict),
 277       &aggregate_device_dict,
 278       &size,
 279       aggregate_device);
 280   if (result != noErr) {
 281     DLOG(ERROR) << "Error creating aggregate audio device!";
 282     return result;
 283   }
 284
 285   // Set the sub-devices for the aggregate device.
 286   // In this case we use two: the input and output devices.
 287
 288   ScopedCFTypeRef<CFStringRef> input_device_UID(GetDeviceUID(input_id));
 289   ScopedCFTypeRef<CFStringRef> output_device_UID(GetDeviceUID(output_id));
 290   if (!input_device_UID || !output_device_UID) {
 291     DLOG(ERROR) << "Error getting audio device UID strings.";
 292     return -1;
 293   }
 294
 295   ScopedCFTypeRef<CFMutableArrayRef> sub_devices_array(
 296       CreateSubDeviceArray(input_device_UID, output_device_UID));
 297   if (sub_devices_array == NULL) {
 298     DLOG(ERROR) << "Error creating sub-devices array.";
 299     return -1;
 300   }
 301
 302   static const AudioObjectPropertyAddress kSetSubDevicesAddress = {
 303     kAudioAggregateDevicePropertyFullSubDeviceList,
 304     kAudioObjectPropertyScopeGlobal,
 305     kAudioObjectPropertyElementMaster
 306   };
 307
 308   size = sizeof(CFMutableArrayRef);
 309   result = AudioObjectSetPropertyData(
 310       *aggregate_device,
 311       &kSetSubDevicesAddress,
 312       0,
 313       NULL,
 314       size,
 315       &sub_devices_array);
 316   if (result != noErr) {
 317     DLOG(ERROR) << "Error setting aggregate audio device sub-devices!";
 318     return result;
 319   }
 320
 321   // Use the input device as the master device.
 322   static const AudioObjectPropertyAddress kSetMasterDeviceAddress = {
 323     kAudioAggregateDevicePropertyMasterSubDevice,
 324     kAudioObjectPropertyScopeGlobal,
 325     kAudioObjectPropertyElementMaster
 326   };
 327
 328   size = sizeof(CFStringRef);
 329   result = AudioObjectSetPropertyData(
 330       *aggregate_device,
 331       &kSetMasterDeviceAddress,
 332       0,
 333       NULL,
 334       size,
 335       &input_device_UID);
 336   if (result != noErr) {
 337     DLOG(ERROR) << "Error setting aggregate audio device master device!";
 338     return result;
 339   }
 340
 341   DVLOG(1) << "New aggregate device: " << *aggregate_device;
 342   return noErr;
 343 }
 344
 345 void AggregateDeviceManager::DestroyAggregateDevice() {
 346   if (aggregate_device_ == kAudioObjectUnknown)
 347     return;
 348
 349   static const AudioObjectPropertyAddress kDestroyAddress = {
 350     kAudioPlugInDestroyAggregateDevice,
 351     kAudioObjectPropertyScopeGlobal,
 352     kAudioObjectPropertyElementMaster
 353   };
 354
 355   UInt32 size = sizeof(aggregate_device_);
 356   OSStatus result = AudioObjectGetPropertyData(
 357       plugin_id_,
 358       &kDestroyAddress,
 359       0,
 360       NULL,
 361       &size,
 362       &aggregate_device_);
 363   if (result != noErr) {
 364     DLOG(ERROR) << "Error destroying aggregate audio device!";
 365     return;
 366   }
 367
 368   aggregate_device_ = kAudioObjectUnknown;
 369 }
 370
 371 }  // namespace media