Add play test.

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>
 
@@ skipping 292 matching lines @@
   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)
+  if (result != noErr || !size) {
+    OSSTATUS_LOG(ERROR, result) << "Failed to get property size... " << size;
     return false;
+  }
 
   std::unique_ptr<uint8_t[]> list_storage(new uint8_t[size]);
   AudioBufferList* buffer_list =
       reinterpret_cast<AudioBufferList*>(list_storage.get());
 
   result = AudioObjectGetPropertyData(device, &pa, 0, 0, &size, buffer_list);
-  if (result != noErr)
+  if (result != noErr) {
+    OSSTATUS_LOG(ERROR, result) << "Failed to get property...";
     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;
 
-  DVLOG(1) << (scope == kAudioDevicePropertyScopeInput ? "Input" : "Output")
-           << " total channels: " << *channels;
+  LOG(ERROR) << (scope == kAudioDevicePropertyScopeInput ? "Input" : "Output")
+             << " total 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 101 matching lines @@
 
   // 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;
+    LOG(ERROR) << "Total count exceeds 8 channels, preferring total count.";
     return true;
   }
 
   AudioObjectPropertyAddress pa = {kAudioDevicePropertyPreferredChannelLayout,
                                    scope, kAudioObjectPropertyElementMaster};
   UInt32 size;
   OSStatus result = AudioObjectGetPropertyDataSize(device, &pa, 0, 0, &size);
-  if (result != noErr || !size)
+  if (result != noErr || !size) {
+    OSSTATUS_LOG(ERROR, result)
+        << "Failed to get property (2) size... " << 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)
+  if (result != noErr) {
+    OSSTATUS_LOG(ERROR, result) << "Failed to get property (2)... ";
     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)
+    if (result != noErr || !size) {
+      OSSTATUS_LOG(ERROR, result) << "Failed to get af info... " << 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)
+    if (result != noErr) {
+      OSSTATUS_LOG(ERROR, result) << "Failed to get af structure... ";
       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;
-  }
+  bool is_au_based_retry = false;
+  do {
+    // 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) << (scope == kAudioDevicePropertyScopeInput ? "Input" : "Output")
-           << " channels: " << *channels;
+    // If we still don't have a channel count, fall back to total channel count.
+    if (*channels == 0 && !is_au_based_retry) {
+      is_au_based_retry = true;
+
+      const AudioUnitScope au_scope =
+          scope == kAudioDevicePropertyScopeOutput ? 0 : 1;
+
+      LOG(ERROR)
+          << "Unable to use channel layout for channel count, trying AU.";
+
+      AudioComponentDescription desc = {kAudioUnitType_Output,
+                                        kAudioUnitSubType_HALOutput,
+                                        kAudioUnitManufacturer_Apple, 0, 0};
+      AudioComponent comp = AudioComponentFindNext(0, &desc);
+      if (!comp) {
+        LOG(ERROR) << "Failed to find component.";
+        return false;
+      }
+
+      AudioUnit audio_unit;
+      result = AudioComponentInstanceNew(comp, &audio_unit);
+      if (result != noErr) {
+        OSSTATUS_LOG(ERROR, result) << "AudioComponentInstanceNew() failed.";
+        return false;
+      }
+
+      Boolean writable;
+      result = AudioUnitGetPropertyInfo(
+          audio_unit, kAudioUnitProperty_AudioChannelLayout,
+          kAudioUnitScope_Output, au_scope, &size, &writable);
+      if (result != noErr) {
+        OSSTATUS_LOG(ERROR, result) << "AudioUnitGetPropertyInfo() failed.";
+        return false;
+      }
+
+      layout_storage.reset(new uint8_t[size]);
+      layout = reinterpret_cast<AudioChannelLayout*>(layout_storage.get());
+
+      result = AudioUnitGetProperty(
+          audio_unit, kAudioUnitProperty_AudioChannelLayout,
+          kAudioUnitScope_Output, au_scope, layout, &size);
+      if (result != noErr) {
+        OSSTATUS_LOG(ERROR, result) << "AudioUnitGetProperty() failed.";
+        return false;
+      }
+
+      result = AudioUnitUninitialize(audio_unit);
+      OSSTATUS_LOG_IF(ERROR, result != noErr, result)
+          << "AudioUnitUninitialize() failed.";
+      result = AudioComponentInstanceDispose(audio_unit);
+      OSSTATUS_LOG_IF(ERROR, result != noErr, result)
+          << "AudioComponentInstanceDispose() failed.";
+    }
+  } while (*channels == 0 && is_au_based_retry);
+
+  LOG(ERROR) << (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 = {
@@ skipping 635 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