Move ChannelLayout into media namespace.

content/renderer/media/webrtc_audio_device_impl.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 "content/renderer/media/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/sample_rates.h"
 
 using content::AudioDeviceFactory;
 using media::AudioParameters;
+using media::ChannelLayout;
 
 static const int64 kMillisecondsBetweenProcessCalls = 5000;
 static const double kMaxVolumeLevel = 255.0;
 
 // Supported hardware sample rates for input and output sides.
 #if defined(OS_WIN) || defined(OS_MACOSX)
 // media::GetAudioInput[Output]HardwareSampleRate() asks the audio layer
 // for its current sample rate (set by the user) on Windows and Mac OS X.
 // The listed rates below adds restrictions and WebRtcAudioDeviceImpl::Init()
 // will fail if the user selects any rate outside these ranges.
@@ skipping 415 matching lines @@
                 in_sample_rate) ==
       &kValidInputRates[arraysize(kValidInputRates)]) {
     DLOG(ERROR) << in_sample_rate << " is not a supported input rate.";
     return -1;
   }
 
   // Ask the browser for the default number of audio input channels.
   // This request is based on a synchronous IPC message.
   ChannelLayout in_channel_layout = audio_hardware::GetInputChannelLayout();
   DVLOG(1) << "Audio input hardware channels: " << in_channel_layout;
-  ChannelLayout out_channel_layout = CHANNEL_LAYOUT_MONO;
+  ChannelLayout out_channel_layout = media::CHANNEL_LAYOUT_MONO;
 
   AudioParameters::Format in_format = AudioParameters::AUDIO_PCM_LINEAR;
   int in_buffer_size = 0;
   int out_buffer_size = 0;
 
   // TODO(henrika): factor out all platform specific parts in separate
   // functions. Code is a bit messy right now.
 
 // Windows
 #if defined(OS_WIN)
   // Always use stereo rendering on Windows.
-  out_channel_layout = CHANNEL_LAYOUT_STEREO;
+  out_channel_layout = media::CHANNEL_LAYOUT_STEREO;
 
   DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Windows.";
   in_format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 
   // Capture side: AUDIO_PCM_LOW_LATENCY is based on the Core Audio (WASAPI)
   // API which was introduced in Windows Vista. For lower Windows versions,
   // a callback-driven Wave implementation is used instead. An input buffer
   // size of 10ms works well for both these implementations.
 
   // Use different buffer sizes depending on the current hardware sample rate.
@@ skipping 26 matching lines @@
   // Windows XP and lower can't cope with 10 ms output buffer size.
   // It must be extended to 30 ms (60 ms will be used internally by WaveOut).
   if (!media::IsWASAPISupported()) {
     out_buffer_size = 3 * out_buffer_size;
     DLOG(WARNING) << "Extending the output buffer size by a factor of three "
                   << "since Windows XP has been detected.";
   }
 
 // Mac OS X
 #elif defined(OS_MACOSX)
-  out_channel_layout = CHANNEL_LAYOUT_MONO;
+  out_channel_layout = media::CHANNEL_LAYOUT_MONO;
 
   DVLOG(1) << "Using AUDIO_PCM_LOW_LATENCY as input mode on Mac OS X.";
   in_format = AudioParameters::AUDIO_PCM_LOW_LATENCY;
 
   // Capture side: AUDIO_PCM_LOW_LATENCY on Mac OS X is based on a callback-
   // driven Core Audio implementation. Tests have shown that 10ms is a suitable
   // frame size to use, both for 48kHz and 44.1kHz.
 
   // Use different buffer sizes depending on the current hardware sample rate.
   if (in_sample_rate == 44100) {
@@ skipping 13 matching lines @@
   // Use different buffer sizes depending on the current hardware sample rate.
   if (out_sample_rate == 48000) {
     out_buffer_size = 480;
   } else {
     // We do run at 44.1kHz at the actual audio layer, but ask for frames
     // at 44.0kHz to ensure that we can feed them to the webrtc::VoiceEngine.
     out_buffer_size = 440;
   }
 // Linux
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
-  in_channel_layout = CHANNEL_LAYOUT_STEREO;
-  out_channel_layout = CHANNEL_LAYOUT_MONO;
+  in_channel_layout = media::CHANNEL_LAYOUT_STEREO;
+  out_channel_layout = media::CHANNEL_LAYOUT_MONO;
 
   // Based on tests using the current ALSA implementation in Chrome, we have
   // found that the best combination is 20ms on the input side and 10ms on the
   // output side.
   // TODO(henrika): It might be possible to reduce the input buffer
   // size and reduce the delay even more.
   in_buffer_size = 2 * 480;
   out_buffer_size = 480;
 #else
   DLOG(ERROR) << "Unsupported platform";
   return -1;
 #endif
 
   // Store utilized parameters to ensure that we can check them
   // after a successful initialization.
   output_audio_parameters_.Reset(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, out_channel_layout,
       out_sample_rate, 16, out_buffer_size);
 
   input_audio_parameters_.Reset(
       in_format, in_channel_layout, in_sample_rate,
       16, in_buffer_size);
 
   // Create and configure the audio capturing client.
   audio_input_device_ = AudioDeviceFactory::NewInputDevice();
   audio_input_device_->Initialize(input_audio_parameters_, this, this);
 
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioOutputChannelLayout",
-                            out_channel_layout, CHANNEL_LAYOUT_MAX);
+                            out_channel_layout, media::CHANNEL_LAYOUT_MAX);
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputChannelLayout",
-                            in_channel_layout, CHANNEL_LAYOUT_MAX);
+                            in_channel_layout, media::CHANNEL_LAYOUT_MAX);
   AddHistogramFramesPerBuffer(kAudioOutput, out_buffer_size);
   AddHistogramFramesPerBuffer(kAudioInput, in_buffer_size);
 
   // Configure the audio rendering client.
   audio_output_device_->Initialize(output_audio_parameters_, this);
 
   DCHECK(audio_input_device_);
 
   // Allocate local audio buffers based on the parameters above.
   // It is assumed that each audio sample contains 16 bits and each
@@ skipping 565 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::GetLoudspeakerStatus(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 void WebRtcAudioDeviceImpl::SetSessionId(int session_id) {
   session_id_ = session_id;
 }