Support AudioContextOptions latencyHint as double.

media/base/audio_latency.cc

 // Copyright 2016 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_latency.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "build/build_config.h"
+#include "media/base/audio_parameters.h"
 
 namespace media {
 
-namespace {
-#if !defined(OS_WIN)
-// Taken from "Bit Twiddling Hacks"
-// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-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;
-}
-#endif
-}  // namespace
-
 // static
 int AudioLatency::GetHighLatencyBufferSize(int sample_rate,

[DaleCurtis, 2017/03/30 18:53:47]

I wasn't proposing you make this change in this CL; since it's something we may
need to revert. You're welcome to include it here, but I think it may be a bit
risky.

[Andrew MacPherson, 2017/03/31 12:31:01]

Sorry, my mistake, I wasn't sure if you were suggesting doing this now or not.
I've reverted this for now to keep this CL as straightforward as possible,
thanks!

                                            int preferred_buffer_size) {
   // Empirically, we consider 20ms of samples to be high latency.
   const double twenty_ms_size = 2.0 * sample_rate / 100;
 
-#if defined(OS_WIN)
   preferred_buffer_size = std::max(preferred_buffer_size, 1);
 
-  // Windows doesn't use power of two buffer sizes, so we should always round up
-  // to the nearest multiple of the output buffer size.
+  // Round up to the nearest multiple of the output buffer size.
   const int high_latency_buffer_size =
       std::ceil(twenty_ms_size / preferred_buffer_size) * preferred_buffer_size;
-#else
-  // On other platforms use the nearest higher power of two buffer size.  For a
-  // given sample rate, this works out to:
-  //
-  //     <= 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.
-  const int high_latency_buffer_size = RoundUpToPowerOfTwo(twenty_ms_size);
-#endif  // defined(OS_WIN)
 
 #if defined(OS_CHROMEOS)

[DaleCurtis, 2017/03/30 18:53:47]

Is this necessary now? We'll always be at least 1 multiple of the preferred
buffer size right?

   return high_latency_buffer_size;  // No preference.
 #else
   return std::max(preferred_buffer_size, high_latency_buffer_size);
 #endif  // defined(OS_CHROMEOS)
 }
 
 // static
 int AudioLatency::GetRtcBufferSize(int sample_rate, int hardware_buffer_size) {
   // Use native hardware buffer size as default. On Windows, we strive to open
   // up using this native hardware buffer size to achieve best
@@ skipping 45 matching lines @@
   // the jitter.
   const int kSmallBufferSize = 1024;
   const int kDefaultCallbackBufferSize = 2048;
   if (hardware_buffer_size <= kSmallBufferSize)
     return kDefaultCallbackBufferSize;
 #endif
 
   return hardware_buffer_size;
 }
 
+int AudioLatency::GetExactBufferSize(base::TimeDelta duration,
+                                     const AudioParameters& hardware_params) {

[DaleCurtis, 2017/03/30 18:53:47]

Should probably just take int sample_rate, int frames_per_buffer like the other
methods.

[Andrew MacPherson, 2017/03/31 12:31:01]

Done.

+  const int hardware_buffer_size = hardware_params.frames_per_buffer();
+  const double requested_buffer_size =
+      duration.InSecondsF() * hardware_params.sample_rate();
+
+  // Round the requested size to the nearest multiple of the hardware size
+  const int buffer_size =
+      std::round(std::max(requested_buffer_size, 1.0) / hardware_buffer_size) *
+      hardware_buffer_size;
+
+  const double twenty_ms_size = 2.0 * hardware_params.sample_rate() / 100;
+  const int max_buffer_size =
+      std::ceil(twenty_ms_size / hardware_buffer_size) * hardware_buffer_size;
+
+  return std::max(std::min(buffer_size, max_buffer_size), hardware_buffer_size);
+}
+
 }  // namespace media