Increase the default buffer size from 128 to 256 on Mac

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"
@@ skipping 421 matching lines @@
   GetAudioDeviceInfo(false, device_names);
 }
 
 AudioParameters AudioManagerMac::GetInputStreamParameters(
     const std::string& device_id) {
   AudioDeviceID device = GetAudioDeviceIdByUId(true, device_id);
   if (device == kAudioObjectUnknown) {
     DLOG(ERROR) << "Invalid device " << device_id;
     return AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
-        kFallbackSampleRate, 16, ChooseBufferSize(kFallbackSampleRate));
+        kFallbackSampleRate, 16, ChooseBufferSize(true, kFallbackSampleRate));
   }
 
   int channels = 0;
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   if (GetDeviceChannels(device, kAudioDevicePropertyScopeInput, &channels) &&
       channels <= 2) {
     channel_layout = GuessChannelLayout(channels);
   } else {
     DLOG(ERROR) << "Failed to get the device channels, use stereo as default "
                 << "for device " << device_id;
   }
 
   int sample_rate = HardwareSampleRateForDevice(device);
   if (!sample_rate)
     sample_rate = kFallbackSampleRate;
 
   // Due to the sharing of the input and output buffer sizes, we need to choose
   // the input buffer size based on the output sample rate.  See
   // http://crbug.com/154352.
-  const int buffer_size = ChooseBufferSize(sample_rate);
+  const int buffer_size = ChooseBufferSize(true, sample_rate);
 
   // TODO(xians): query the native channel layout for the specific device.
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
       sample_rate, 16, buffer_size);
 }
 
 std::string AudioManagerMac::GetAssociatedOutputDeviceID(
     const std::string& input_device_id) {
   AudioDeviceID device = GetAudioDeviceIdByUId(true, input_device_id);
@@ skipping 160 matching lines @@
 }
 
 AudioParameters AudioManagerMac::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
   const AudioDeviceID device = GetAudioDeviceIdByUId(false, output_device_id);
   if (device == kAudioObjectUnknown) {
     DLOG(ERROR) << "Invalid output device " << output_device_id;
     return input_params.IsValid() ? input_params : AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
-        kFallbackSampleRate, 16, ChooseBufferSize(kFallbackSampleRate));
+        kFallbackSampleRate, 16, ChooseBufferSize(false, kFallbackSampleRate));
   }
 
   const bool has_valid_input_params = input_params.IsValid();
   const int hardware_sample_rate = HardwareSampleRateForDevice(device);
 
   // Allow pass through buffer sizes.  If concurrent input and output streams
   // exist, they will use the smallest buffer size amongst them.  As such, each
   // stream must be able to FIFO requests appropriately when this happens.
-  int buffer_size = ChooseBufferSize(hardware_sample_rate);
+  int buffer_size = ChooseBufferSize(false, hardware_sample_rate);
   if (has_valid_input_params) {
     buffer_size =
         std::min(kMaximumInputOutputBufferSize,
                  std::max(input_params.frames_per_buffer(), buffer_size));
   }
 
   int hardware_channels;
   if (!GetDeviceChannels(device, kAudioDevicePropertyScopeOutput,
                          &hardware_channels)) {
     hardware_channels = 2;
@@ skipping 47 matching lines @@
 
   if (current_sample_rate_ == new_sample_rate &&
       current_output_device_ == new_output_device)
     return;
 
   current_sample_rate_ = new_sample_rate;
   current_output_device_ = new_output_device;
   NotifyAllOutputDeviceChangeListeners();
 }
 
-int AudioManagerMac::ChooseBufferSize(int output_sample_rate) {
-  int buffer_size = kMinimumInputOutputBufferSize;
+int AudioManagerMac::ChooseBufferSize(bool is_input, int sample_rate) {
+  // kMinimumInputOutputBufferSize is too small for the output side because
+  // CoreAudio can get into under-run if the renderer fails delivering data
+  // to the browser within the allowed time by the OS. The workaround is to
+  // use 256 samples as the default output buffer size for sample rates
+  // smaller than 96KHz.
+  // TODO(xians): Remove this workaround after WebAudio supports user defined
+  // buffer size.  See https://github.com/WebAudio/web-audio-api/issues/348
+  // for details.
+  int buffer_size = is_input ?
+      kMinimumInputOutputBufferSize : 2 * kMinimumInputOutputBufferSize;
   const int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size) {
     buffer_size = user_buffer_size;
-  } else if (output_sample_rate > 48000) {
+  } else if (sample_rate > 48000) {
     // The default buffer size is too small for higher sample rates and may lead
     // to glitching.  Adjust upwards by multiples of the default size.
-    if (output_sample_rate <= 96000)
+    if (sample_rate <= 96000)
       buffer_size = 2 * kMinimumInputOutputBufferSize;
-    else if (output_sample_rate <= 192000)
+    else if (sample_rate <= 192000)
       buffer_size = 4 * kMinimumInputOutputBufferSize;
   }
 
   return buffer_size;
 }
 
 bool AudioManagerMac::ShouldDeferStreamStart() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   return power_observer_->ShouldDeferStreamStart();
 }
 
 void AudioManagerMac::ReleaseOutputStream(AudioOutputStream* stream) {
   output_streams_.remove(stream);
   AudioManagerBase::ReleaseOutputStream(stream);
 }
 
 void AudioManagerMac::ReleaseInputStream(AudioInputStream* stream) {
   input_streams_.remove(stream);
   AudioManagerBase::ReleaseInputStream(stream);
 }
 
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
   return new AudioManagerMac(audio_log_factory);
 }
 
 }  // namespace media