Make OS audio buffer size limits visible.

media/audio/cras/audio_manager_cras.cc

 // Copyright 2013 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/cras/audio_manager_cras.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/nix/xdg_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/sys_info.h"
 #include "chromeos/audio/audio_device.h"
 #include "chromeos/audio/cras_audio_handler.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_features.h"
 #include "media/audio/cras/cras_input.h"
 #include "media/audio/cras/cras_unified.h"
 #include "media/base/channel_layout.h"
 #include "media/base/localized_strings.h"
 
 // cras_util.h headers pull in min/max macros...
 // TODO(dgreid): Fix headers such that these aren't imported.
 #undef min
 #undef max
 
 namespace media {
 namespace {
 
 // Maximum number of output streams that can be open simultaneously.
 const int kMaxOutputStreams = 50;
 
 // Default sample rate for input and output streams.
 const int kDefaultSampleRate = 48000;
 
-// Define bounds for the output buffer size.
-const int kMinimumOutputBufferSize = 512;
-const int kMaximumOutputBufferSize = 8192;
-
 // Default input buffer size.
 const int kDefaultInputBufferSize = 1024;
 
 const char kBeamformingOnDeviceId[] = "default-beamforming-on";
 const char kBeamformingOffDeviceId[] = "default-beamforming-off";
 
 const char kInternalInputVirtualDevice[] = "Built-in mic";
 const char kInternalOutputVirtualDevice[] = "Built-in speaker";
 const char kHeadphoneLineOutVirtualDevice[] = "Headphone/Line Out";
 
@@ skipping 236 matching lines @@
 }
 
 AudioInputStream* AudioManagerCras::MakeLowLatencyInputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const LogCallback& log_callback) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   return MakeInputStream(params, device_id);
 }
 
-int AudioManagerCras::GetMinimumOutputBufferSizePerBoard() {
-  // On faster boards we can use smaller buffer size for lower latency.
-  // On slower boards we should use larger buffer size to prevent underrun.
-  std::string board = base::SysInfo::GetLsbReleaseBoard();
-  if (board == "kevin")
-    return 768;
-  else if (board == "samus")
-    return 256;
-  return kMinimumOutputBufferSize;
-}
-
 AudioParameters AudioManagerCras::GetPreferredOutputStreamParameters(
     const std::string& output_device_id,
     const AudioParameters& input_params) {
   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
   int sample_rate = kDefaultSampleRate;
-  int buffer_size = GetMinimumOutputBufferSizePerBoard();
+  int buffer_size = AudioLatency::GetDefaultAudioBufferSize(false, sample_rate);

[o1ka, 2017/05/30 16:04:33]

Sorry, now I lost the track of what is going on.
Why is the need to modify GetPreferredOutputStreamParameters? They are not
WebAudio-only.

For WebAudio GetPreferredOutputStreamParameters() result is returned to
AudioManagerBase::GetDefaultOutputStreamParameters() and ends up in
AudioOutputDevice::GetOutputDeviceInfo() on the renderer side. So HW buffer size
will be minimum buffer size both on ChromeOS and Mac if I'm not mistaken.


Why not to follow dalecurtis@'s recommendation (which I've just noticed)
described in the bug the CL is referencing
(https://bugs.chromium.org/p/chromium/issues/detail?id=708917)?

AudioLatency is renderer-side application-aware concept, and AudioManager is
browser-side platform audio system abstraction; none of them can depend on the
other.

   int bits_per_sample = 16;
   if (input_params.IsValid()) {
     sample_rate = input_params.sample_rate();
     bits_per_sample = input_params.bits_per_sample();
     channel_layout = input_params.channel_layout();
     buffer_size =
-        std::min(kMaximumOutputBufferSize,
+        std::min(AudioLatency::GetMaximumAudioBufferSize(sample_rate),
                  std::max(buffer_size, input_params.frames_per_buffer()));
   }
 
   int user_buffer_size = GetUserBufferSize();
   if (user_buffer_size)
     buffer_size = user_buffer_size;
 
   return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
                          sample_rate, bits_per_sample, buffer_size);
 }
@@ skipping 26 matching lines @@
 
 bool AudioManagerCras::IsDefault(const std::string& device_id, bool is_input) {
   AudioDeviceNames device_names;
   GetAudioDeviceNamesImpl(is_input, &device_names);
   DCHECK(!device_names.empty());
   const AudioDeviceName& device_name = device_names.front();
   return device_name.unique_id == device_id;
 }
 
 }  // namespace media