add audio-buffer-size command line flag support to the input audio for all the platforms

media/audio/win/audio_manager_win.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/audio_io.h"
 
 #include <windows.h>
 #include <objbase.h>  // This has to be before initguid.h
 #include <initguid.h>
 #include <mmsystem.h>
@@ skipping 281 matching lines @@
 
 void AudioManagerWin::GetAudioInputDeviceNames(AudioDeviceNames* device_names) {
   GetAudioDeviceNamesImpl(true, device_names);
 }
 
 void AudioManagerWin::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
   GetAudioDeviceNamesImpl(false, device_names);
 }
 
-AudioParameters AudioManagerWin::GetInputStreamParameters(
-    const std::string& device_id) {
-  AudioParameters parameters;
-  if (!core_audio_supported()) {
-    // Windows Wave implementation is being used.
-    parameters = AudioParameters(
-        AudioParameters::AUDIO_PCM_LINEAR, CHANNEL_LAYOUT_STEREO, 0, 48000,
-        16, kFallbackBufferSize, AudioParameters::NO_EFFECTS);
-  } else  {
-    parameters = WASAPIAudioInputStream::GetInputStreamParameters(device_id);
+AudioParameters AudioManagerWin::GetPreferredInputStreamParameters(
+    const std::string& input_device_id,
+    const AudioParameters& input_params) {
+  // Default format used by the wave implementation.
+  AudioParameters::Format format = AUDIO_PCM_LINEAR;
+  ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
+  int buffer_size = kFallbackBufferSize;
+  int bits_per_sample = 16;
+  int input_channels = 0;
+  int sample_rate = 48000;
+  int effects = AudioParameters::NO_EFFECTS;
+
+  if (core_audio_supported()) {
+    // When core audio is being used, we need to respect the native format
+    // of the device.
+    AudioParameters parameters =
+        WASAPIAudioInputStream::GetInputStreamParameters(device_id);
+    format = parameters.format();
+    channel_layout = parameters.channel_layout();
+    bits_per_sample = parameters.bits_per_sample();
+    input_channels = parameters.input_channels();
+    sample_rate = parameters.sample_rate();
+    effects |= parameters.effects();
+  }
+
+  if (input_params.IsValid()) {
+    input_channels = input_params.input_channels();
+    effects |= input_params.effects();
+    bits_per_sample = input_params.bits_per_sample();
+    buffer_size = input_params.frames_per_buffer();
+    channel_layout = input_params.channel_layout();
+
+    // When core audio is being used, we must use the device's native sample
+    // rate.
+    if (!core_audio_supported())
+      sample_rate = input_params.sample_rate();
   }
 
   int user_buffer_size = GetUserBufferSize();
-  if (user_buffer_size) {
-    parameters.Reset(parameters.format(), parameters.channel_layout(),
-                     parameters.channels(), parameters.input_channels(),
-                     parameters.sample_rate(), parameters.bits_per_sample(),
-                     user_buffer_size);
-  }
+  if (user_buffer_size)
+    buffer_size = user_buffer_size;
 
-  return parameters;
+  return AudioParameters(format, channel_layout, input_channels,
+                         sample_rate, bits_per_sample, buffer_size, effects);
 }
 
 std::string AudioManagerWin::GetAssociatedOutputDeviceID(
     const std::string& input_device_id) {
   if (!core_audio_supported()) {
     NOTIMPLEMENTED()
         << "GetAssociatedOutputDeviceID is not supported on this OS";
     return std::string();
   }
   return CoreAudioUtil::GetMatchingOutputDeviceID(input_device_id);
@@ skipping 195 matching lines @@
   return new PCMWaveInAudioInputStream(this, params, kNumInputBuffers,
                                        xp_device_id);
 }
 
 /// static
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
   return new AudioManagerWin(audio_log_factory);
 }
 
 }  // namespace media