Fix for CoreAudio stereo problem for unknown speakers

media/audio/mac/audio_output_mac.cc

 // Copyright (c) 2011 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_output_mac.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/audio/audio_util.h"
@@ skipping 78 matching lines @@
   // pointer while we operate here. Note that does not mean that the source
   // has been destroyed.
   AudioSourceCallback* source = source_;
   if (source)
     source->OnError(this, static_cast<int>(err));
   NOTREACHED() << "error code " << err;
 }
 
 bool PCMQueueOutAudioOutputStream::Open() {
   // Get the default device id.
-  unsigned int device_id = 0;
+  AudioObjectID device_id = 0;
   AudioObjectPropertyAddress property_address = {
       kAudioHardwarePropertyDefaultOutputDevice,
       kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster
   };
   UInt32 device_id_size = sizeof(device_id);
   OSStatus err = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                             &property_address, 0, NULL,
                                             &device_id_size, &device_id);
   if (err != noErr) {
     HandleError(err);
     return false;
   }
   // Get the size of the channel layout.
   UInt32 core_layout_size;
+  // TODO(annacc): AudioDeviceGetPropertyInfo() is deprecated, but its
+  // replacement, AudioObjectGetPropertyDataSize(), doesn't work yet with
+  // kAudioDevicePropertyPreferredChannelLayout.
   err = AudioDeviceGetPropertyInfo(device_id, 0, false,
                                    kAudioDevicePropertyPreferredChannelLayout,
                                    &core_layout_size, NULL);
   if (err != noErr) {
     HandleError(err);
     return false;
   }
   // Get the device's channel layout.  This layout may vary in sized based on
   // the number of channels.  Use |core_layout_size| to allocate memory.
   scoped_ptr_malloc<AudioChannelLayout> core_channel_layout;
   core_channel_layout.reset(
       reinterpret_cast<AudioChannelLayout*>(malloc(core_layout_size)));
   memset(core_channel_layout.get(), 0, core_layout_size);
+  // TODO(annacc): AudioDeviceGetProperty() is deprecated, but its
+  // replacement, AudioObjectGetPropertyData(), doesn't work yet with
+  // kAudioDevicePropertyPreferredChannelLayout.
   err = AudioDeviceGetProperty(device_id, 0, false,
                                kAudioDevicePropertyPreferredChannelLayout,
                                &core_layout_size, core_channel_layout.get());
   if (err != noErr) {
     HandleError(err);
     return false;
   }
 
   num_core_channels_ =
       static_cast<int>(core_channel_layout->mNumberChannelDescriptions);
@@ skipping 29 matching lines @@
   err = AudioQueueSetParameter(audio_queue_, kAudioQueueParam_Volume, 1.0);
   if (err != noErr) {
     HandleError(err);
     return false;
   }
 
   // Capture channel layout in a format we can use.
   for (int i = 0; i < CHANNELS_MAX; ++i)
     core_channel_orderings_[i] = kEmptyChannel;
 
+  bool all_channels_unknown = true;
   for (int i = 0; i < num_core_channels_; ++i) {
-    switch (core_channel_layout->mChannelDescriptions[i].mChannelLabel) {
+    AudioChannelLabel label =
+        core_channel_layout->mChannelDescriptions[i].mChannelLabel;
+    if (label == kAudioChannelLabel_Unknown) {
+      continue;
+    }
+    all_channels_unknown = false;
+    switch (label) {
       case kAudioChannelLabel_Left:
         core_channel_orderings_[LEFT] = i;
         channel_remap_[i] = kChannelOrderings[source_layout_][LEFT];
         break;
       case kAudioChannelLabel_Right:
         core_channel_orderings_[RIGHT] = i;
         channel_remap_[i] = kChannelOrderings[source_layout_][RIGHT];
         break;
       case kAudioChannelLabel_Center:
         core_channel_orderings_[CENTER] = i;
@@ skipping 31 matching lines @@
         core_channel_orderings_[BACK_RIGHT] = i;
         channel_remap_[i] = kChannelOrderings[source_layout_][BACK_RIGHT];
         break;
       default:
         DLOG(WARNING) << "Channel label not supported";
         channel_remap_[i] = kEmptyChannel;
         break;
     }
   }
 
+  if (all_channels_unknown) {
+    return true;
+  }
+
   // Check if we need to adjust the layout.
   // If the device has a BACK_LEFT and no SIDE_LEFT and the source has
   // a SIDE_LEFT but no BACK_LEFT, then move (and preserve the channel).
   // e.g. CHANNEL_LAYOUT_5POINT1 -> CHANNEL_LAYOUT_5POINT1_BACK
   CheckForAdjustedLayout(SIDE_LEFT, BACK_LEFT);
   // Same for SIDE_RIGHT -> BACK_RIGHT.
   CheckForAdjustedLayout(SIDE_RIGHT, BACK_RIGHT);
   // Move BACK_LEFT to SIDE_LEFT.
   // e.g. CHANNEL_LAYOUT_5POINT1_BACK -> CHANNEL_LAYOUT_5POINT1
   CheckForAdjustedLayout(BACK_LEFT, SIDE_LEFT);
   // Same for BACK_RIGHT -> SIDE_RIGHT.
   CheckForAdjustedLayout(BACK_RIGHT, SIDE_RIGHT);
   // Move SIDE_LEFT to LEFT_OF_CENTER.
   // e.g. CHANNEL_LAYOUT_7POINT1 -> CHANNEL_LAYOUT_7POINT1_WIDE
   CheckForAdjustedLayout(SIDE_LEFT, LEFT_OF_CENTER);
   // Same for SIDE_RIGHT -> RIGHT_OF_CENTER.
   CheckForAdjustedLayout(SIDE_RIGHT, RIGHT_OF_CENTER);
   // Move LEFT_OF_CENTER to SIDE_LEFT.
   // e.g. CHANNEL_LAYOUT_7POINT1_WIDE -> CHANNEL_LAYOUT_7POINT1
   CheckForAdjustedLayout(LEFT_OF_CENTER, SIDE_LEFT);
   // Same for RIGHT_OF_CENTER -> SIDE_RIGHT.
   CheckForAdjustedLayout(RIGHT_OF_CENTER, SIDE_RIGHT);
+  // For MONO -> STEREO, move audio to LEFT and RIGHT if applicable.
+  CheckForAdjustedLayout(CENTER, LEFT);
+  CheckForAdjustedLayout(CENTER, RIGHT);
 
   // Check if we will need to swizzle from source to device layout (maybe not!).
   should_swizzle_ = false;
   for (int i = 0; i < num_core_channels_; ++i) {
     if (kChannelOrderings[source_layout_][i] != core_channel_orderings_[i]) {
       should_swizzle_ = true;
       break;
     }
   }
 
@@ skipping 206 matching lines @@
       HandleError(err);
       return;
     }
   }
   err  = AudioQueueStart(audio_queue_, NULL);
   if (err != noErr) {
     HandleError(err);
     return;
   }
 }