Use AudioUnit instead of AudioDevice properties to get channel count.

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 <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_observer.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/mac/audio_auhal_mac.h"
 #include "media/audio/mac/audio_input_mac.h"
 #include "media/audio/mac/audio_low_latency_input_mac.h"
+#include "media/audio/mac/scoped_audio_unit.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/channel_layout.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 
 namespace media {
 
 // Maximum number of output streams that can be open simultaneously.
 static const int kMaxOutputStreams = 50;
@@ skipping 251 matching lines @@
     DLOG(ERROR) << "Error getting default AudioDevice.";
     return false;
   }
   return true;
 }
 
 static bool GetDefaultOutputDevice(AudioDeviceID* device) {
   return GetDefaultDevice(device, false);
 }
 
-// Returns the total number of channels on a device; regardless of what the
-// device's preferred rendering layout looks like. Should only be used for the
-// channel count when a device has more than kMaxConcurrentChannels.
-static bool GetDeviceTotalChannelCount(AudioDeviceID device,
-                                       AudioObjectPropertyScope scope,
-                                       int* channels) {
+static bool GetDeviceChannels(AudioDeviceID device,
+                              AUElement element,
+                              int* channels) {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   CHECK(channels);
 
-  // Get the stream configuration of the device in an AudioBufferList (with the
-  // buffer pointers set to nullptr) which describes the list of streams and the
-  // number of channels in each stream.
-  AudioObjectPropertyAddress pa = {kAudioDevicePropertyStreamConfiguration,
-                                   scope, kAudioObjectPropertyElementMaster};
-
-  UInt32 size;
-  OSStatus result = AudioObjectGetPropertyDataSize(device, &pa, 0, 0, &size);
-  if (result != noErr || !size)
+  ScopedAudioUnit au(device, element);
+  if (!au.is_valid())
     return false;
 
-  std::unique_ptr<uint8_t[]> list_storage(new uint8_t[size]);
-  AudioBufferList* buffer_list =
-      reinterpret_cast<AudioBufferList*>(list_storage.get());
+  // Attempt to retrieve the channel layout from the AudioUnit.
+  //
+  // Note: We don't use kAudioDevicePropertyPreferredChannelLayout on the device
+  // because it is not available on all devices.
+  UInt32 size;
+  Boolean writable;
+  OSStatus result = AudioUnitGetPropertyInfo(
+      au.audio_unit(), kAudioUnitProperty_AudioChannelLayout,
+      kAudioUnitScope_Output, element, &size, &writable);
+  if (result != noErr) {
+    OSSTATUS_DLOG(ERROR, result)
+        << "Failed to get property info for AudioUnit channel layout.";
+    return false;
+  }
 
-  result = AudioObjectGetPropertyData(device, &pa, 0, 0, &size, buffer_list);
-  if (result != noErr)
+  std::unique_ptr<uint8_t[]> layout_storage(new uint8_t[size]);
+  AudioChannelLayout* layout =
+      reinterpret_cast<AudioChannelLayout*>(layout_storage.get());
+
+  result = AudioUnitGetProperty(au.audio_unit(),
+                                kAudioUnitProperty_AudioChannelLayout,
+                                kAudioUnitScope_Output, element, layout, &size);
+  if (result != noErr) {
+    OSSTATUS_LOG(ERROR, result) << "Failed to get AudioUnit channel layout.";
     return false;
+  }
 
-  // Determine number of channels based on the AudioBufferList.
-  // |mNumberBuffers] is the  number of interleaved channels in the buffer.
-  // If the number is 1, the buffer is noninterleaved.
-  *channels = 0;
-  for (UInt32 i = 0; i < buffer_list->mNumberBuffers; ++i)
-    *channels += buffer_list->mBuffers[i].mNumberChannels;
+  // We don't want to have to know about all channel layout tags, so force OSX
+  // to give us the channel descriptions from the bitmap or tag if necessary.
+  const AudioChannelLayoutTag tag = layout->mChannelLayoutTag;
+  if (tag != kAudioChannelLayoutTag_UseChannelDescriptions) {
+    const bool is_bitmap = tag == kAudioChannelLayoutTag_UseChannelBitmap;
+    const AudioFormatPropertyID fa =
+        is_bitmap ? kAudioFormatProperty_ChannelLayoutForBitmap
+                  : kAudioFormatProperty_ChannelLayoutForTag;
 
-  DVLOG(1) << (scope == kAudioDevicePropertyScopeInput ? "Input" : "Output")
-           << " total channels: " << *channels;
+    if (is_bitmap) {
+      result = AudioFormatGetPropertyInfo(fa, sizeof(UInt32),
+                                          &layout->mChannelBitmap, &size);
+    } else {
+      result = AudioFormatGetPropertyInfo(fa, sizeof(AudioChannelLayoutTag),
+                                          &tag, &size);
+    }
+    if (result != noErr || !size) {
+      OSSTATUS_DLOG(ERROR, result)
+          << "Failed to get AudioFormat property info, size=" << size;
+      return false;
+    }
+
+    layout_storage.reset(new uint8_t[size]);
+    layout = reinterpret_cast<AudioChannelLayout*>(layout_storage.get());
+    if (is_bitmap) {
+      result = AudioFormatGetProperty(fa, sizeof(UInt32),
+                                      &layout->mChannelBitmap, &size, layout);
+    } else {
+      result = AudioFormatGetProperty(fa, sizeof(AudioChannelLayoutTag), &tag,
+                                      &size, layout);
+    }
+    if (result != noErr) {
+      OSSTATUS_DLOG(ERROR, result) << "Failed to get AudioFormat property.";
+      return false;
+    }
+  }
+
+  // There is no channel info for stereo, assume so for mono as well.
+  if (layout->mNumberChannelDescriptions <= 2) {
+    *channels = layout->mNumberChannelDescriptions;
+  } else {
+    *channels = 0;
+    for (UInt32 i = 0; i < layout->mNumberChannelDescriptions; ++i) {
+      if (layout->mChannelDescriptions[i].mChannelLabel !=
+          kAudioChannelLabel_Unknown)
+        (*channels)++;
+    }
+  }
+
+  DVLOG(1) << (element == AUElement::OUTPUT ? "Output" : "Input")
+           << " channels: " << *channels;
   return true;
 }
 
 class AudioManagerMac::AudioPowerObserver : public base::PowerObserver {
  public:
   AudioPowerObserver()
       : is_suspending_(false),
         is_monitoring_(base::PowerMonitor::Get()),
         num_resume_notifications_(0) {
     // The PowerMonitor requires significant setup (a CFRunLoop and preallocated
@@ skipping 86 matching lines @@
 
 bool AudioManagerMac::HasAudioOutputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultOutputDevice);
 }
 
 bool AudioManagerMac::HasAudioInputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultInputDevice);
 }
 
 // static
-bool AudioManagerMac::GetDeviceChannels(AudioDeviceID device,
-                                        AudioObjectPropertyScope scope,
-                                        int* channels) {
-  DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
-  CHECK(channels);
-
-  // If the device has more channels than possible for layouts to express, use
-  // the total count of channels on the device; as of this writing, macOS will
-  // only return up to 8 channels in any layout. To allow WebAudio to work with
-  // > 8 channel devices, we must use the total channel count instead of the
-  // channel count of the preferred layout.
-  int total_channel_count = 0;
-  if (GetDeviceTotalChannelCount(device, scope, &total_channel_count) &&
-      total_channel_count > kMaxConcurrentChannels) {
-    *channels = total_channel_count;
-    return true;
-  }
-
-  AudioObjectPropertyAddress pa = {kAudioDevicePropertyPreferredChannelLayout,
-                                   scope, kAudioObjectPropertyElementMaster};
-  UInt32 size;
-  OSStatus result = AudioObjectGetPropertyDataSize(device, &pa, 0, 0, &size);
-  if (result != noErr || !size)
-    return false;
-
-  std::unique_ptr<uint8_t[]> layout_storage(new uint8_t[size]);
-  AudioChannelLayout* layout =
-      reinterpret_cast<AudioChannelLayout*>(layout_storage.get());
-  result = AudioObjectGetPropertyData(device, &pa, 0, 0, &size, layout);
-  if (result != noErr)
-    return false;
-
-  // We don't want to have to know about all channel layout tags, so force OSX
-  // to give us the channel descriptions from the bitmap or tag if necessary.
-  const AudioChannelLayoutTag tag = layout->mChannelLayoutTag;
-  if (tag != kAudioChannelLayoutTag_UseChannelDescriptions) {
-    const bool is_bitmap = tag == kAudioChannelLayoutTag_UseChannelBitmap;
-    const AudioFormatPropertyID fa =
-        is_bitmap ? kAudioFormatProperty_ChannelLayoutForBitmap
-                  : kAudioFormatProperty_ChannelLayoutForTag;
-
-    if (is_bitmap) {
-      result = AudioFormatGetPropertyInfo(fa, sizeof(UInt32),
-                                          &layout->mChannelBitmap, &size);
-    } else {
-      result = AudioFormatGetPropertyInfo(fa, sizeof(AudioChannelLayoutTag),
-                                          &tag, &size);
-    }
-    if (result != noErr || !size)
-      return false;
-
-    layout_storage.reset(new uint8_t[size]);
-    layout = reinterpret_cast<AudioChannelLayout*>(layout_storage.get());
-    if (is_bitmap) {
-      result = AudioFormatGetProperty(fa, sizeof(UInt32),
-                                      &layout->mChannelBitmap, &size, layout);
-    } else {
-      result = AudioFormatGetProperty(fa, sizeof(AudioChannelLayoutTag), &tag,
-                                      &size, layout);
-    }
-    if (result != noErr)
-      return false;
-  }
-
-  // There is no channel info for stereo, assume so for mono as well.
-  if (layout->mNumberChannelDescriptions <= 2) {
-    *channels = layout->mNumberChannelDescriptions;
-  } else {
-    *channels = 0;
-    for (UInt32 i = 0; i < layout->mNumberChannelDescriptions; ++i) {
-      if (layout->mChannelDescriptions[i].mChannelLabel !=
-          kAudioChannelLabel_Unknown)
-        (*channels)++;
-    }
-  }
-
-  // If we still don't have a channel count, fall back to total channel count.
-  if (*channels == 0) {
-    DLOG(WARNING) << "Unable to use channel layout for channel count.";
-    *channels = total_channel_count;
-  }
-
-  DVLOG(1) << (scope == kAudioDevicePropertyScopeInput ? "Input" : "Output")
-           << " channels: " << *channels;
-  return true;
-}
-
-// static
 int AudioManagerMac::HardwareSampleRateForDevice(AudioDeviceID device_id) {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   Float64 nominal_sample_rate;
   UInt32 info_size = sizeof(nominal_sample_rate);
 
   static const AudioObjectPropertyAddress kNominalSampleRateAddress = {
       kAudioDevicePropertyNominalSampleRate,
       kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster
   };
@@ skipping 33 matching lines @@
   DCHECK(device_names->empty());
   GetAudioDeviceInfo(false, device_names);
 }
 
 AudioParameters AudioManagerMac::GetInputStreamParameters(
     const std::string& device_id) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   AudioDeviceID device = GetAudioDeviceIdByUId(true, device_id);
   if (device == kAudioObjectUnknown) {
     DLOG(ERROR) << "Invalid device " << device_id;
-    return AudioParameters(
-        AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
-        kFallbackSampleRate, 16, ChooseBufferSize(true, kFallbackSampleRate));
+    return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                           CHANNEL_LAYOUT_STEREO, kFallbackSampleRate, 16,
+                           ChooseBufferSize(true, kFallbackSampleRate));
   }
 
   int channels = 0;
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
-  if (GetDeviceChannels(device, kAudioDevicePropertyScopeInput, &channels) &&
-      channels <= 2) {
+  if (GetDeviceChannels(device, AUElement::INPUT, &channels) && channels <= 2) {
     channel_layout = GuessChannelLayout(channels);
   } else {
     DLOG(ERROR) << "Failed to get the device channels, use stereo as default "
                 << "for device " << device_id;
   }
 
   int sample_rate = HardwareSampleRateForDevice(device);
   if (!sample_rate)
     sample_rate = kFallbackSampleRate;
 
@@ skipping 219 matching lines @@
   // exist, they will use the smallest buffer size amongst them.  As such, each
   // stream must be able to FIFO requests appropriately when this happens.
   int buffer_size = ChooseBufferSize(false, hardware_sample_rate);
   if (has_valid_input_params) {
     buffer_size =
         std::min(kMaximumInputOutputBufferSize,
                  std::max(input_params.frames_per_buffer(), buffer_size));
   }
 
   int hardware_channels;
-  if (!GetDeviceChannels(device, kAudioDevicePropertyScopeOutput,
-                         &hardware_channels)) {
+  if (!GetDeviceChannels(device, AUElement::OUTPUT, &hardware_channels))
     hardware_channels = 2;
-  }
 
   // Use the input channel count and channel layout if possible.  Let OSX take
   // care of remapping the channels; this lets user specified channel layouts
   // work correctly.
   int output_channels = input_params.channels();
   ChannelLayout channel_layout = input_params.channel_layout();
   if (!has_valid_input_params || output_channels > hardware_channels) {
     output_channels = hardware_channels;
     channel_layout = GuessChannelLayout(output_channels);
     if (channel_layout == CHANNEL_LAYOUT_UNSUPPORTED)
@@ skipping 326 matching lines @@
 ScopedAudioManagerPtr CreateAudioManager(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory) {
   return ScopedAudioManagerPtr(
       new AudioManagerMac(std::move(task_runner), std::move(worker_task_runner),
                           audio_log_factory));
 }
 
 }  // namespace media