Moved AudioUtil static functions to AudioManager interfaces

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 <CoreAudio/AudioHardware.h>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/sys_string_conversions.h"
-#include "media/audio/audio_util.h"
+#include "media/audio/audio_parameters.h"
 #include "media/audio/mac/audio_input_mac.h"
 #include "media/audio/mac/audio_low_latency_input_mac.h"
 #include "media/audio/mac/audio_low_latency_output_mac.h"
 #include "media/audio/mac/audio_output_mac.h"
 #include "media/audio/mac/audio_synchronized_mac.h"
 #include "media/audio/mac/audio_unified_mac.h"
 #include "media/base/bind_to_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;
 
+// Default buffer size in samples for low-latency input and output streams.
+static const int kDefaultLowLatencyBufferSize = 128;
+
 static bool HasAudioHardware(AudioObjectPropertySelector selector) {
   AudioDeviceID output_device_id = kAudioObjectUnknown;
   const AudioObjectPropertyAddress property_address = {
     selector,
     kAudioObjectPropertyScopeGlobal,            // mScope
     kAudioObjectPropertyElementMaster           // mElement
   };
   UInt32 output_device_id_size = static_cast<UInt32>(sizeof(output_device_id));
   OSStatus err = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                             &property_address,
@@ skipping 225 matching lines @@
     // Prepend the default device to the list since we always want it to be
     // on the top of the list for all platforms. There is no duplicate
     // counting here since the default device has been abstracted out before.
     media::AudioDeviceName name;
     name.device_name = AudioManagerBase::kDefaultDeviceName;
     name.unique_id =  AudioManagerBase::kDefaultDeviceId;
     device_names->push_front(name);
   }
 }
 
+AudioParameters AudioManagerMac::GetDefaultOutputStreamParameters(
+    const AudioParameters& input_params) {
+  ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
+  int input_channels = 0;
+  if (input_params.IsValid()) {
+    channel_layout = input_params.channel_layout();
+    input_channels = input_params.input_channels();
+
+    if (CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kEnableWebAudioInput)) {
+      // TODO(crogers): given the limitations of the AudioOutputStream
+      // back-ends used with kEnableWebAudioInput, we hard-code to stereo.
+      // Specifically, this is a limitation of AudioSynchronizedStream which
+      // can be removed as part of the work to consolidate these back-ends.
+      channel_layout = CHANNEL_LAYOUT_STEREO;
+    }
+  }
+
+  return AudioParameters(
+      AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, input_channels,
+      AUAudioOutputStream::HardwareSampleRate(), 16,
+      kDefaultLowLatencyBufferSize);
+}
+
+AudioParameters AudioManagerMac::GetInputStreamParameters(
+    const std::string& device_id) {
+  // TODO(xians): query the native channel layout for the specific device.
+  return AudioParameters(
+      AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
+      AUAudioInputStream::HardwareSampleRate(), 16,
+      kDefaultLowLatencyBufferSize);
+}
+
 AudioOutputStream* AudioManagerMac::MakeLinearOutputStream(
     const AudioParameters& params) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   return new PCMQueueOutAudioOutputStream(this, params);
 }
 
 AudioOutputStream* AudioManagerMac::MakeLowLatencyOutputStream(
     const AudioParameters& params) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
 
@@ skipping 28 matching lines @@
   // Gets the AudioDeviceID that refers to the AudioOutputDevice with the device
   // unique id. This AudioDeviceID is used to set the device for Audio Unit.
   AudioDeviceID audio_device_id = GetAudioDeviceIdByUId(true, device_id);
   AudioInputStream* stream = NULL;
   if (audio_device_id != kAudioObjectUnknown)
     stream = new AUAudioInputStream(this, params, audio_device_id);
 
   return stream;
 }
 
-AudioParameters AudioManagerMac::GetPreferredLowLatencyOutputStreamParameters(
-    const AudioParameters& input_params) {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableWebAudioInput)) {
-    // TODO(crogers): given the limitations of the AudioOutputStream
-    // back-ends used with kEnableWebAudioInput, we hard-code to stereo.
-    // Specifically, this is a limitation of AudioSynchronizedStream which
-    // can be removed as part of the work to consolidate these back-ends.
-    return AudioParameters(
-        AudioParameters::AUDIO_PCM_LOW_LATENCY,
-        CHANNEL_LAYOUT_STEREO, input_params.input_channels(),
-        GetAudioHardwareSampleRate(), 16, GetAudioHardwareBufferSize());
-  }
-
-  return AudioManagerBase::GetPreferredLowLatencyOutputStreamParameters(
-      input_params);
-}
-
 void AudioManagerMac::CreateDeviceListener() {
   DCHECK(GetMessageLoop()->BelongsToCurrentThread());
   output_device_listener_.reset(new AudioDeviceListenerMac(base::Bind(
       &AudioManagerMac::DelayedDeviceChange, base::Unretained(this))));
 }
 
 void AudioManagerMac::DestroyDeviceListener() {
   DCHECK(GetMessageLoop()->BelongsToCurrentThread());
   output_device_listener_.reset();
 }
 
 void AudioManagerMac::DelayedDeviceChange() {
   // TODO(dalecurtis): This is ridiculous, but we need to delay device changes
   // to workaround threading issues with OSX property listener callbacks.  See
   // http://crbug.com/158170
   GetMessageLoop()->PostDelayedTask(FROM_HERE, base::Bind(
       &AudioManagerMac::NotifyAllOutputDeviceChangeListeners,
       base::Unretained(this)), base::TimeDelta::FromSeconds(2));
 }
 
 AudioManager* CreateAudioManager() {
   return new AudioManagerMac();
 }
 
 }  // namespace media