Move ChannelLayout into media namespace.

media/audio/mac/audio_output_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_output_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 120 matching lines @@
       reinterpret_cast<AudioChannelLayout*>(malloc(core_layout_size)));
   memset(core_channel_layout.get(), 0, core_layout_size);
   err = AudioObjectGetPropertyData(device_id, &property_address, 0, NULL,
                                    &core_layout_size,
                                    core_channel_layout.get());
   if (err != noErr) {
     HandleError(err);
     return false;
   }
 
-  num_core_channels_ =
-      static_cast<int>(core_channel_layout->mNumberChannelDescriptions);
+  num_core_channels_ = std::min(
+      static_cast<int>(CHANNELS_MAX),
+      static_cast<int>(core_channel_layout->mNumberChannelDescriptions));
   if (num_core_channels_ == 2 &&
       ChannelLayoutToChannelCount(source_layout_) > 2) {
     should_down_mix_ = true;
     format_.mChannelsPerFrame = num_core_channels_;
     format_.mBytesPerFrame = (format_.mBitsPerChannel >> 3) *
         format_.mChannelsPerFrame;
     format_.mBytesPerPacket = format_.mBytesPerFrame * format_.mFramesPerPacket;
   } else {
     should_down_mix_ = false;
   }
@@ skipping 30 matching lines @@
   for (int i = 0; i < num_core_channels_; ++i) {
     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];
+        channel_remap_[i] = ChannelOrder(source_layout_, LEFT);
         break;
       case kAudioChannelLabel_Right:
         core_channel_orderings_[RIGHT] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][RIGHT];
+        channel_remap_[i] = ChannelOrder(source_layout_, RIGHT);
         break;
       case kAudioChannelLabel_Center:
         core_channel_orderings_[CENTER] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][CENTER];
+        channel_remap_[i] = ChannelOrder(source_layout_, CENTER);
         break;
       case kAudioChannelLabel_LFEScreen:
         core_channel_orderings_[LFE] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][LFE];
+        channel_remap_[i] = ChannelOrder(source_layout_, LFE);
         break;
       case kAudioChannelLabel_LeftSurround:
         core_channel_orderings_[SIDE_LEFT] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][SIDE_LEFT];
+        channel_remap_[i] = ChannelOrder(source_layout_, SIDE_LEFT);
         break;
       case kAudioChannelLabel_RightSurround:
         core_channel_orderings_[SIDE_RIGHT] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][SIDE_RIGHT];
+        channel_remap_[i] = ChannelOrder(source_layout_, SIDE_RIGHT);
         break;
       case kAudioChannelLabel_LeftCenter:
         core_channel_orderings_[LEFT_OF_CENTER] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][LEFT_OF_CENTER];
+        channel_remap_[i] = ChannelOrder(source_layout_, LEFT_OF_CENTER);
         break;
       case kAudioChannelLabel_RightCenter:
         core_channel_orderings_[RIGHT_OF_CENTER] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][RIGHT_OF_CENTER];
+        channel_remap_[i] = ChannelOrder(source_layout_, RIGHT_OF_CENTER);
         break;
       case kAudioChannelLabel_CenterSurround:
         core_channel_orderings_[BACK_CENTER] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][BACK_CENTER];
+        channel_remap_[i] = ChannelOrder(source_layout_, BACK_CENTER);
         break;
       case kAudioChannelLabel_RearSurroundLeft:
         core_channel_orderings_[BACK_LEFT] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][BACK_LEFT];
+        channel_remap_[i] = ChannelOrder(source_layout_, BACK_LEFT);
         break;
       case kAudioChannelLabel_RearSurroundRight:
         core_channel_orderings_[BACK_RIGHT] = i;
-        channel_remap_[i] = kChannelOrderings[source_layout_][BACK_RIGHT];
+        channel_remap_[i] = ChannelOrder(source_layout_, BACK_RIGHT);
         break;
       default:
         DLOG(WARNING) << "Channel label not supported";
         channel_remap_[i] = kEmptyChannel;
         break;
     }
   }
 
   if (all_channels_unknown) {
     return true;
@@ skipping 21 matching lines @@
   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]) {
+    if (ChannelOrder(source_layout_, static_cast<Channels>(i)) !=
+        core_channel_orderings_[i]) {
       should_swizzle_ = true;
       break;
     }
   }
 
   return true;
 }
 
 void PCMQueueOutAudioOutputStream::Close() {
   // It is valid to call Close() before calling Open(), thus audio_queue_
@@ skipping 66 matching lines @@
       }
     }
   }
 }
 
 bool PCMQueueOutAudioOutputStream::CheckForAdjustedLayout(
     Channels input_channel,
     Channels output_channel) {
   if (core_channel_orderings_[output_channel] > kEmptyChannel &&
       core_channel_orderings_[input_channel] == kEmptyChannel &&
-      kChannelOrderings[source_layout_][input_channel] > kEmptyChannel &&
-      kChannelOrderings[source_layout_][output_channel] == kEmptyChannel) {
+      ChannelOrder(source_layout_, input_channel) > kEmptyChannel &&
+      ChannelOrder(source_layout_, output_channel) == kEmptyChannel) {
     channel_remap_[core_channel_orderings_[output_channel]] =
-        kChannelOrderings[source_layout_][input_channel];
+        ChannelOrder(source_layout_, input_channel);
     return true;
   }
   return false;
 }
 
 // Note to future hackers of this function: Do not add locks to this function
 // that are held through any calls made back into AudioQueue APIs, or other
 // OS audio functions.  This is because the OS dispatch may grab external
 // locks, or possibly re-enter this function which can lead to a deadlock.
 void PCMQueueOutAudioOutputStream::RenderCallback(void* p_this,
@@ skipping 165 matching lines @@
   source_ = source;
 }
 
 AudioOutputStream::AudioSourceCallback*
 PCMQueueOutAudioOutputStream::GetSource() {
   base::AutoLock lock(source_lock_);
   return source_;
 }
 
 }  // namespace media