Use larger buffer sizes for lower power on Linux.

media/base/audio_hardware_config.cc

 // Copyright (c) 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/base/audio_hardware_config.h"
 
+#include <algorithm>
+
+#include "base/logging.h"
+#include "build/build_config.h"
+
 using base::AutoLock;
 using media::AudioParameters;
 
 namespace media {
 
+// Taken from "Bit Twiddling Hacks"
+// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+static uint32_t RoundUpToPowerOfTwo(uint32_t v) {
+  v--;
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  v++;
+  return v;
+}
+
 AudioHardwareConfig::AudioHardwareConfig(
     const AudioParameters& input_params,
     const AudioParameters& output_params)
     : input_params_(input_params),
       output_params_(output_params) {
+  DCHECK(input_params_.IsValid());
+  DCHECK(output_params_.IsValid());
 }
 
 AudioHardwareConfig::~AudioHardwareConfig() {}
 
 int AudioHardwareConfig::GetOutputBufferSize() const {
   AutoLock auto_lock(config_lock_);
   return output_params_.frames_per_buffer();
 }
 
 int AudioHardwareConfig::GetOutputSampleRate() const {
@@ skipping 43 matching lines @@
   AutoLock auto_lock(config_lock_);
   input_params_ = input_params;
 }
 
 void AudioHardwareConfig::UpdateOutputConfig(
     const AudioParameters& output_params) {
   AutoLock auto_lock(config_lock_);
   output_params_ = output_params;
 }
 
+int AudioHardwareConfig::GetHighLatencyBufferSize() const {
+  AutoLock auto_lock(config_lock_);
+#if defined(OS_LINUX)
+  // Empirically, use the nearest higher power of two buffer size corresponding
+  // to 20 ms worth of samples.  For a given sample rate, this works out to:

[no longer working on chromium, 2014/04/14 08:51:50]

curiously, 20ms does not sound "high" latency, why do you want to use that? 
why not simply a large hard coded buffer size like 2048?

[DaleCurtis, 2014/04/14 18:08:18]

As discussed in the meeting this morning, I choose 20ms because for a couple
reasons:
- It results in the same buffer size as Flash for 44.1kHz and 48kHz (our most
common hw sample rates).
- It's not so long that pages still using <audio> to play effects (instead of
WebAudio) will suffer during looping or when listening for the ended event.

+  //
+  //     <= 3200   : 64
+  //     <= 6400   : 128
+  //     <= 12800  : 256
+  //     <= 25600  : 512
+  //     <= 51200  : 1024
+  //     <= 102400 : 2048
+  //     <= 204800 : 4096
+  //
+  // On Linux, the minimum hardware buffer size is 512, so the lower calculated
+  // values are unused.  OSX may have a value as low as 128.  Windows is device

[henrika (OOO until Aug 14), 2014/04/14 08:03:24]

Should comments about OSX and Windows be within defined(OS_LINUX)?

[DaleCurtis, 2014/04/14 18:08:18]

I hope eventually this section will have all OS, seems unnecessary to update the
comment every time :)

+  // dependent but will generally be sample_rate() / 100.
+  const int high_latency_buffer_size =
+      RoundUpToPowerOfTwo(2 * output_params_.sample_rate() / 100);
+  return std::max(output_params_.frames_per_buffer(), high_latency_buffer_size);
+#else
+  return output_params_.frames_per_buffer();
+#endif
+}
+
 }  // namespace media