media/audio/mac/audio_manager_mac.cc

   1 // Copyright (c) 2012 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/audio_manager_mac.h"
   6
   7 #include <CoreAudio/AudioHardware.h>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "base/command_line.h"
  12 #include "base/mac/mac_logging.h"
  13 #include "base/mac/scoped_cftyperef.h"
  14 #include "base/strings/sys_string_conversions.h"
  15 #include "media/audio/audio_parameters.h"
  16 #include "media/audio/audio_util.h"
  17 #include "media/audio/mac/audio_auhal_mac.h"
  18 #include "media/audio/mac/audio_input_mac.h"
  19 #include "media/audio/mac/audio_low_latency_input_mac.h"
  20 #include "media/audio/mac/audio_low_latency_output_mac.h"
  21 #include "media/audio/mac/audio_synchronized_mac.h"
  22 #include "media/audio/mac/audio_unified_mac.h"
  23 #include "media/base/bind_to_loop.h"
  24 #include "media/base/channel_layout.h"
  25 #include "media/base/limits.h"
  26 #include "media/base/media_switches.h"
  27
  28 namespace media {
  29
  30 // Maximum number of output streams that can be open simultaneously.
  31 static const int kMaxOutputStreams = 50;
  32
  33 // Default buffer size in samples for low-latency input and output streams.
  34 static const int kDefaultLowLatencyBufferSize = 128;
  35
  36 // Default sample-rate on most Apple hardware.
  37 static const int kFallbackSampleRate = 44100;
  38
  39 static int ChooseBufferSize(int output_sample_rate) {
  40   int buffer_size = kDefaultLowLatencyBufferSize;
  41   const int user_buffer_size = GetUserBufferSize();
  42   if (user_buffer_size) {
  43     buffer_size = user_buffer_size;
  44   } else if (output_sample_rate > 48000) {
  45     // The default buffer size is too small for higher sample rates and may lead
  46     // to glitching.  Adjust upwards by multiples of the default size.
  47     if (output_sample_rate <= 96000)
  48       buffer_size = 2 * kDefaultLowLatencyBufferSize;
  49     else if (output_sample_rate <= 192000)
  50       buffer_size = 4 * kDefaultLowLatencyBufferSize;
  51   }
  52
  53   return buffer_size;
  54 }
  55
  56 static bool HasAudioHardware(AudioObjectPropertySelector selector) {
  57   AudioDeviceID output_device_id = kAudioObjectUnknown;
  58   const AudioObjectPropertyAddress property_address = {
  59     selector,
  60     kAudioObjectPropertyScopeGlobal,            // mScope
  61     kAudioObjectPropertyElementMaster           // mElement
  62   };
  63   UInt32 output_device_id_size = static_cast<UInt32>(sizeof(output_device_id));
  64   OSStatus err = AudioObjectGetPropertyData(kAudioObjectSystemObject,
  65                                             &property_address,
  66                                             0,     // inQualifierDataSize
  67                                             NULL,  // inQualifierData
  68                                             &output_device_id_size,
  69                                             &output_device_id);
  70   return err == kAudioHardwareNoError &&
  71       output_device_id != kAudioObjectUnknown;
  72 }
  73
  74 // Returns true if the default input device is the same as
  75 // the default output device.
  76 bool AudioManagerMac::HasUnifiedDefaultIO() {
  77   AudioDeviceID input_id, output_id;
  78   if (!GetDefaultInputDevice(&input_id) || !GetDefaultOutputDevice(&output_id))
  79     return false;
  80
  81   return input_id == output_id;
  82 }
  83
  84 static void GetAudioDeviceInfo(bool is_input,
  85                                media::AudioDeviceNames* device_names) {
  86   DCHECK(device_names);
  87   device_names->clear();
  88
  89   // Query the number of total devices.
  90   AudioObjectPropertyAddress property_address = {
  91     kAudioHardwarePropertyDevices,
  92     kAudioObjectPropertyScopeGlobal,
  93     kAudioObjectPropertyElementMaster
  94   };
  95   UInt32 size = 0;
  96   OSStatus result = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject,
  97                                                    &property_address,
  98                                                    0,
  99                                                    NULL,
 100                                                    &size);
 101   if (result || !size)
 102     return;
 103
 104   int device_count = size / sizeof(AudioDeviceID);
 105
 106   // Get the array of device ids for all the devices, which includes both
 107   // input devices and output devices.
 108   scoped_ptr_malloc<AudioDeviceID>
 109       devices(reinterpret_cast<AudioDeviceID*>(malloc(size)));
 110   AudioDeviceID* device_ids = devices.get();
 111   result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
 112                                       &property_address,
 113                                       0,
 114                                       NULL,
 115                                       &size,
 116                                       device_ids);
 117   if (result)
 118     return;
 119
 120   // Iterate over all available devices to gather information.
 121   for (int i = 0; i < device_count; ++i) {
 122     // Get the number of input or output channels of the device.
 123     property_address.mScope = is_input ?
 124         kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;
 125     property_address.mSelector = kAudioDevicePropertyStreams;
 126     size = 0;
 127     result = AudioObjectGetPropertyDataSize(device_ids[i],
 128                                             &property_address,
 129                                             0,
 130                                             NULL,
 131                                             &size);
 132     if (result || !size)
 133       continue;
 134
 135     // Get device UID.
 136     CFStringRef uid = NULL;
 137     size = sizeof(uid);
 138     property_address.mSelector = kAudioDevicePropertyDeviceUID;
 139     property_address.mScope = kAudioObjectPropertyScopeGlobal;
 140     result = AudioObjectGetPropertyData(device_ids[i],
 141                                         &property_address,
 142                                         0,
 143                                         NULL,
 144                                         &size,
 145                                         &uid);
 146     if (result)
 147       continue;
 148
 149     // Get device name.
 150     CFStringRef name = NULL;
 151     property_address.mSelector = kAudioObjectPropertyName;
 152     property_address.mScope = kAudioObjectPropertyScopeGlobal;
 153     result = AudioObjectGetPropertyData(device_ids[i],
 154                                         &property_address,
 155                                         0,
 156                                         NULL,
 157                                         &size,
 158                                         &name);
 159     if (result) {
 160       if (uid)
 161         CFRelease(uid);
 162       continue;
 163     }
 164
 165     // Store the device name and UID.
 166     media::AudioDeviceName device_name;
 167     device_name.device_name = base::SysCFStringRefToUTF8(name);
 168     device_name.unique_id = base::SysCFStringRefToUTF8(uid);
 169     device_names->push_back(device_name);
 170
 171     // We are responsible for releasing the returned CFObject.  See the
 172     // comment in the AudioHardware.h for constant
 173     // kAudioDevicePropertyDeviceUID.
 174     if (uid)
 175       CFRelease(uid);
 176     if (name)
 177       CFRelease(name);
 178   }
 179 }
 180
 181 static AudioDeviceID GetAudioDeviceIdByUId(bool is_input,
 182                                            const std::string& device_id) {
 183   AudioObjectPropertyAddress property_address = {
 184     kAudioHardwarePropertyDevices,
 185     kAudioObjectPropertyScopeGlobal,
 186     kAudioObjectPropertyElementMaster
 187   };
 188   AudioDeviceID audio_device_id = kAudioObjectUnknown;
 189   UInt32 device_size = sizeof(audio_device_id);
 190   OSStatus result = -1;
 191
 192   if (device_id == AudioManagerBase::kDefaultDeviceId) {
 193     // Default Device.
 194     property_address.mSelector = is_input ?
 195         kAudioHardwarePropertyDefaultInputDevice :
 196         kAudioHardwarePropertyDefaultOutputDevice;
 197
 198     result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
 199                                         &property_address,
 200                                         0,
 201                                         0,
 202                                         &device_size,
 203                                         &audio_device_id);
 204   } else {
 205     // Non-default device.
 206     base::ScopedCFTypeRef<CFStringRef> uid(
 207         base::SysUTF8ToCFStringRef(device_id));
 208     AudioValueTranslation value;
 209     value.mInputData = &uid;
 210     value.mInputDataSize = sizeof(CFStringRef);
 211     value.mOutputData = &audio_device_id;
 212     value.mOutputDataSize = device_size;
 213     UInt32 translation_size = sizeof(AudioValueTranslation);
 214
 215     property_address.mSelector = kAudioHardwarePropertyDeviceForUID;
 216     result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
 217                                         &property_address,
 218                                         0,
 219                                         0,
 220                                         &translation_size,
 221                                         &value);
 222   }
 223
 224   if (result) {
 225     OSSTATUS_DLOG(WARNING, result) << "Unable to query device " << device_id
 226                                    << " for AudioDeviceID";
 227   }
 228
 229   return audio_device_id;
 230 }
 231
 232 AudioManagerMac::AudioManagerMac()
 233     : current_sample_rate_(0) {
 234   current_output_device_ = kAudioDeviceUnknown;
 235
 236   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 237
 238   // Task must be posted last to avoid races from handing out "this" to the
 239   // audio thread.  Always PostTask even if we're on the right thread since
 240   // AudioManager creation is on the startup path and this may be slow.
 241   GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
 242       &AudioManagerMac::CreateDeviceListener, base::Unretained(this)));
 243 }
 244
 245 AudioManagerMac::~AudioManagerMac() {
 246   if (GetMessageLoop()->BelongsToCurrentThread()) {
 247     DestroyDeviceListener();
 248   } else {
 249     // It's safe to post a task here since Shutdown() will wait for all tasks to
 250     // complete before returning.
 251     GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
 252         &AudioManagerMac::DestroyDeviceListener, base::Unretained(this)));
 253   }
 254
 255   Shutdown();
 256 }
 257
 258 bool AudioManagerMac::HasAudioOutputDevices() {
 259   return HasAudioHardware(kAudioHardwarePropertyDefaultOutputDevice);
 260 }
 261
 262 bool AudioManagerMac::HasAudioInputDevices() {
 263   return HasAudioHardware(kAudioHardwarePropertyDefaultInputDevice);
 264 }
 265
 266 // TODO(crogers): There are several places on the OSX specific code which
 267 // could benefit from these helper functions.
 268 bool AudioManagerMac::GetDefaultInputDevice(
 269     AudioDeviceID* device) {
 270   return GetDefaultDevice(device, true);
 271 }
 272
 273 bool AudioManagerMac::GetDefaultOutputDevice(
 274     AudioDeviceID* device) {
 275   return GetDefaultDevice(device, false);
 276 }
 277
 278 bool AudioManagerMac::GetDefaultDevice(
 279     AudioDeviceID* device, bool input) {
 280   CHECK(device);
 281
 282   // Obtain the current output device selected by the user.
 283   AudioObjectPropertyAddress pa;
 284   pa.mSelector = input ? kAudioHardwarePropertyDefaultInputDevice :
 285       kAudioHardwarePropertyDefaultOutputDevice;
 286   pa.mScope = kAudioObjectPropertyScopeGlobal;
 287   pa.mElement = kAudioObjectPropertyElementMaster;
 288
 289   UInt32 size = sizeof(*device);
 290
 291   OSStatus result = AudioObjectGetPropertyData(
 292       kAudioObjectSystemObject,
 293       &pa,
 294       0,
 295       0,
 296       &size,
 297       device);
 298
 299   if ((result != kAudioHardwareNoError) || (*device == kAudioDeviceUnknown)) {
 300     DLOG(ERROR) << "Error getting default AudioDevice.";
 301     return false;
 302   }
 303
 304   return true;
 305 }
 306
 307 bool AudioManagerMac::GetDefaultOutputChannels(
 308     int* channels) {
 309   AudioDeviceID device;
 310   if (!GetDefaultOutputDevice(&device))
 311     return false;
 312
 313   return GetDeviceChannels(device,
 314                            kAudioDevicePropertyScopeOutput,
 315                            channels);
 316 }
 317
 318 bool AudioManagerMac::GetDeviceChannels(
 319     AudioDeviceID device,
 320     AudioObjectPropertyScope scope,
 321     int* channels) {
 322   CHECK(channels);
 323
 324   // Get stream configuration.
 325   AudioObjectPropertyAddress pa;
 326   pa.mSelector = kAudioDevicePropertyStreamConfiguration;
 327   pa.mScope = scope;
 328   pa.mElement = kAudioObjectPropertyElementMaster;
 329
 330   UInt32 size;
 331   OSStatus result = AudioObjectGetPropertyDataSize(device, &pa, 0, 0, &size);
 332   if (result != noErr || !size)
 333     return false;
 334
 335   // Allocate storage.
 336   scoped_ptr<uint8[]> list_storage(new uint8[size]);
 337   AudioBufferList& buffer_list =
 338       *reinterpret_cast<AudioBufferList*>(list_storage.get());
 339
 340   result = AudioObjectGetPropertyData(
 341       device,
 342       &pa,
 343       0,
 344       0,
 345       &size,
 346       &buffer_list);
 347   if (result != noErr)
 348     return false;
 349
 350   // Determine number of input channels.
 351   int channels_per_frame = buffer_list.mNumberBuffers > 0 ?
 352       buffer_list.mBuffers[0].mNumberChannels : 0;
 353   if (channels_per_frame == 1 && buffer_list.mNumberBuffers > 1) {
 354     // Non-interleaved.
 355     *channels = buffer_list.mNumberBuffers;
 356   } else {
 357     // Interleaved.
 358     *channels = channels_per_frame;
 359   }
 360
 361   return true;
 362 }
 363
 364 int AudioManagerMac::HardwareSampleRateForDevice(AudioDeviceID device_id) {
 365   Float64 nominal_sample_rate;
 366   UInt32 info_size = sizeof(nominal_sample_rate);
 367
 368   static const AudioObjectPropertyAddress kNominalSampleRateAddress = {
 369       kAudioDevicePropertyNominalSampleRate,
 370       kAudioObjectPropertyScopeGlobal,
 371       kAudioObjectPropertyElementMaster
 372   };
 373   OSStatus result = AudioObjectGetPropertyData(
 374       device_id,
 375       &kNominalSampleRateAddress,
 376       0,
 377       0,
 378       &info_size,
 379       &nominal_sample_rate);
 380   if (result != noErr) {
 381     OSSTATUS_DLOG(WARNING, result)
 382         << "Could not get default sample rate for device: " << device_id;
 383     return 0;
 384   }
 385
 386   return static_cast<int>(nominal_sample_rate);
 387 }
 388
 389 int AudioManagerMac::HardwareSampleRate() {
 390   // Determine the default output device's sample-rate.
 391   AudioDeviceID device_id = kAudioObjectUnknown;
 392   if (!GetDefaultOutputDevice(&device_id))
 393     return kFallbackSampleRate;
 394
 395   return HardwareSampleRateForDevice(device_id);
 396 }
 397
 398 void AudioManagerMac::GetAudioInputDeviceNames(
 399     media::AudioDeviceNames* device_names) {
 400   GetAudioDeviceInfo(true, device_names);
 401   if (!device_names->empty()) {
 402     // Prepend the default device to the list since we always want it to be
 403     // on the top of the list for all platforms. There is no duplicate
 404     // counting here since the default device has been abstracted out before.
 405     media::AudioDeviceName name;
 406     name.device_name = AudioManagerBase::kDefaultDeviceName;
 407     name.unique_id =  AudioManagerBase::kDefaultDeviceId;
 408     device_names->push_front(name);
 409   }
 410 }
 411
 412 AudioParameters AudioManagerMac::GetInputStreamParameters(
 413     const std::string& device_id) {
 414   // Due to the sharing of the input and output buffer sizes, we need to choose
 415   // the input buffer size based on the output sample rate.  See
 416   // http://crbug.com/154352.
 417   const int buffer_size = ChooseBufferSize(
 418       AUAudioOutputStream::HardwareSampleRate());
 419
 420   AudioDeviceID device = GetAudioDeviceIdByUId(true, device_id);
 421   if (device == kAudioObjectUnknown) {
 422     DLOG(ERROR) << "Invalid device " << device_id;
 423     return AudioParameters();
 424   }
 425
 426   int channels = 0;
 427   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
 428   if (GetDeviceChannels(device, kAudioDevicePropertyScopeInput, &channels) &&
 429       channels <= 2) {
 430     channel_layout = GuessChannelLayout(channels);
 431   } else {
 432     DLOG(ERROR) << "Failed to get the device channels, use stereo as default "
 433                 << "for device " << device_id;
 434   }
 435
 436   int sample_rate = HardwareSampleRateForDevice(device);
 437   if (!sample_rate)
 438     sample_rate = kFallbackSampleRate;
 439
 440   // TODO(xians): query the native channel layout for the specific device.
 441   return AudioParameters(
 442       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
 443       sample_rate, 16, buffer_size);
 444 }
 445
 446 AudioOutputStream* AudioManagerMac::MakeLinearOutputStream(
 447     const AudioParameters& params) {
 448   return MakeLowLatencyOutputStream(params, std::string());
 449 }
 450
 451 AudioOutputStream* AudioManagerMac::MakeLowLatencyOutputStream(
 452     const AudioParameters& params, const std::string& input_device_id) {
 453   // Handle basic output with no input channels.
 454   if (params.input_channels() == 0) {
 455     AudioDeviceID device = kAudioObjectUnknown;
 456     GetDefaultOutputDevice(&device);
 457     return new AUHALStream(this, params, device);
 458   }
 459
 460   // TODO(crogers): support more than stereo input.
 461   if (params.input_channels() != 2) {
 462     // WebAudio is currently hard-coded to 2 channels so we should not
 463     // see this case.
 464     NOTREACHED() << "Only stereo input is currently supported!";
 465     return NULL;
 466   }
 467
 468   AudioDeviceID device = kAudioObjectUnknown;
 469   if (HasUnifiedDefaultIO()) {
 470     // For I/O, the simplest case is when the default input and output
 471     // devices are the same.
 472     GetDefaultOutputDevice(&device);
 473     LOG(INFO) << "UNIFIED: default input and output devices are identical";
 474   } else {
 475     // Some audio hardware is presented as separate input and output devices
 476     // even though they are really the same physical hardware and
 477     // share the same "clock domain" at the lowest levels of the driver.
 478     // A common of example of this is the "built-in" audio hardware:
 479     //     "Built-in Line Input"
 480     //     "Built-in Output"
 481     // We would like to use an "aggregate" device for these situations, since
 482     // CoreAudio will make the most efficient use of the shared "clock domain"
 483     // so we get the lowest latency and use fewer threads.
 484     device = aggregate_device_manager_.GetDefaultAggregateDevice();
 485     if (device != kAudioObjectUnknown)
 486       LOG(INFO) << "Using AGGREGATE audio device";
 487   }
 488
 489   if (device != kAudioObjectUnknown &&
 490       input_device_id == AudioManagerBase::kDefaultDeviceId)
 491     return new AUHALStream(this, params, device);
 492
 493   // Fallback to AudioSynchronizedStream which will handle completely
 494   // different and arbitrary combinations of input and output devices
 495   // even running at different sample-rates.
 496   // kAudioDeviceUnknown translates to "use default" here.
 497   // TODO(crogers): consider tracking UMA stats on AUHALStream
 498   // versus AudioSynchronizedStream.
 499   AudioDeviceID audio_device_id = GetAudioDeviceIdByUId(true, input_device_id);
 500   if (audio_device_id == kAudioObjectUnknown)
 501     return NULL;
 502
 503   return new AudioSynchronizedStream(this,
 504                                      params,
 505                                      audio_device_id,
 506                                      kAudioDeviceUnknown);
 507 }
 508
 509 AudioInputStream* AudioManagerMac::MakeLinearInputStream(
 510     const AudioParameters& params, const std::string& device_id) {
 511   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
 512   return new PCMQueueInAudioInputStream(this, params);
 513 }
 514
 515 AudioInputStream* AudioManagerMac::MakeLowLatencyInputStream(
 516     const AudioParameters& params, const std::string& device_id) {
 517   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
 518   // Gets the AudioDeviceID that refers to the AudioOutputDevice with the device
 519   // unique id. This AudioDeviceID is used to set the device for Audio Unit.
 520   AudioDeviceID audio_device_id = GetAudioDeviceIdByUId(true, device_id);
 521   AudioInputStream* stream = NULL;
 522   if (audio_device_id != kAudioObjectUnknown)
 523     stream = new AUAudioInputStream(this, params, audio_device_id);
 524
 525   return stream;
 526 }
 527
 528 AudioParameters AudioManagerMac::GetPreferredOutputStreamParameters(
 529     const AudioParameters& input_params) {
 530   int hardware_channels = 2;
 531   if (!GetDefaultOutputChannels(&hardware_channels)) {
 532     // Fallback to stereo.
 533     hardware_channels = 2;
 534   }
 535
 536   ChannelLayout channel_layout = GuessChannelLayout(hardware_channels);
 537
 538   const int hardware_sample_rate = AUAudioOutputStream::HardwareSampleRate();
 539   const int buffer_size = ChooseBufferSize(hardware_sample_rate);
 540
 541   int input_channels = 0;
 542   if (input_params.IsValid()) {
 543     input_channels = input_params.input_channels();
 544
 545     if (input_channels > 0) {
 546       // TODO(crogers): given the limitations of the AudioOutputStream
 547       // back-ends used with synchronized I/O, we hard-code to stereo.
 548       // Specifically, this is a limitation of AudioSynchronizedStream which
 549       // can be removed as part of the work to consolidate these back-ends.
 550       channel_layout = CHANNEL_LAYOUT_STEREO;
 551     }
 552   }
 553
 554   AudioParameters params(
 555       AudioParameters::AUDIO_PCM_LOW_LATENCY,
 556       channel_layout,
 557       input_channels,
 558       hardware_sample_rate,
 559       16,
 560       buffer_size);
 561
 562   if (channel_layout == CHANNEL_LAYOUT_UNSUPPORTED)
 563     params.SetDiscreteChannels(hardware_channels);
 564
 565   return params;
 566 }
 567
 568 void AudioManagerMac::CreateDeviceListener() {
 569   DCHECK(GetMessageLoop()->BelongsToCurrentThread());
 570
 571   // Get a baseline for the sample-rate and current device,
 572   // so we can intelligently handle device notifications only when necessary.
 573   current_sample_rate_ = HardwareSampleRate();
 574   if (!GetDefaultOutputDevice(&current_output_device_))
 575     current_output_device_ = kAudioDeviceUnknown;
 576
 577   output_device_listener_.reset(new AudioDeviceListenerMac(base::Bind(
 578       &AudioManagerMac::HandleDeviceChanges, base::Unretained(this))));
 579 }
 580
 581 void AudioManagerMac::DestroyDeviceListener() {
 582   DCHECK(GetMessageLoop()->BelongsToCurrentThread());
 583   output_device_listener_.reset();
 584 }
 585
 586 void AudioManagerMac::HandleDeviceChanges() {
 587   if (!GetMessageLoop()->BelongsToCurrentThread()) {
 588     GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
 589         &AudioManagerMac::HandleDeviceChanges, base::Unretained(this)));
 590     return;
 591   }
 592
 593   int new_sample_rate = HardwareSampleRate();
 594   AudioDeviceID new_output_device;
 595   GetDefaultOutputDevice(&new_output_device);
 596
 597   if (current_sample_rate_ == new_sample_rate &&
 598       current_output_device_ == new_output_device)
 599     return;
 600
 601   current_sample_rate_ = new_sample_rate;
 602   current_output_device_ = new_output_device;
 603   NotifyAllOutputDeviceChangeListeners();
 604 }
 605
 606 AudioManager* CreateAudioManager() {
 607   return new AudioManagerMac();
 608 }
 609
 610 }  // namespace media