| OLD | NEW |
|---|
| (Empty) |
| 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(¤t_input_device); | |
| 34 AudioManagerMac::GetDefaultOutputDevice(¤t_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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 163343002:
Reland 153623004: Remove the unified IO code on the browser (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master