Support for AudioContextOptions latencyHint.

third_party/WebKit/Source/platform/audio/AudioDestination.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 16 matching lines @@
  */
 
 #include "platform/audio/AudioDestination.h"
 
 #include "platform/Histogram.h"
 #include "platform/audio/AudioFIFO.h"
 #include "platform/audio/AudioPullFIFO.h"
 #include "platform/audio/AudioUtilities.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebAudioLatencyHint.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 // Size of the FIFO
 const size_t fifoSize = 8192;
 
 // Factory method: Chromium-implementation
 std::unique_ptr<AudioDestination> AudioDestination::create(
     AudioIOCallback& callback,
     const String& inputDeviceId,
     unsigned numberOfInputChannels,
     unsigned numberOfOutputChannels,
-    float sampleRate,
+    const WebAudioLatencyHint& latencyHint,
     PassRefPtr<SecurityOrigin> securityOrigin) {
   return wrapUnique(new AudioDestination(
       callback, inputDeviceId, numberOfInputChannels, numberOfOutputChannels,
-      sampleRate, std::move(securityOrigin)));
+      latencyHint, std::move(securityOrigin)));
 }
 
 AudioDestination::AudioDestination(AudioIOCallback& callback,
                                    const String& inputDeviceId,
                                    unsigned numberOfInputChannels,
                                    unsigned numberOfOutputChannels,
-                                   float sampleRate,
+                                   const WebAudioLatencyHint& latencyHint,

[o1ka, 2016/11/30 11:46:26]

WebAudioLatencyHint class really makes the code look heavier: const refs are not
needed if we use enum directly.

[Raymond Toy, 2016/11/30 21:50:27]

I think this is the right approach because the latencyHint will eventually
include a double in addition to the enum.  I've proposed that the IDL should
include that, and to treat any float value as the same as interactive.  At least
for the first cut.

                                    PassRefPtr<SecurityOrigin> securityOrigin)
     : m_callback(callback),
       m_numberOfOutputChannels(numberOfOutputChannels),
       m_inputBus(AudioBus::create(numberOfInputChannels,
                                   AudioUtilities::kRenderQuantumFrames)),
       m_renderBus(AudioBus::create(numberOfOutputChannels,
                                    AudioUtilities::kRenderQuantumFrames,
                                    false)),
-      m_sampleRate(sampleRate),
       m_isPlaying(false) {
   // Histogram for audioHardwareBufferSize
   DEFINE_STATIC_LOCAL(SparseHistogram, hardwareBufferSizeHistogram,
                       ("WebAudio.AudioDestination.HardwareBufferSize"));
   // Histogram for the actual callback size used.  Typically, this is the same
   // as audioHardwareBufferSize, but can be adjusted depending on some
   // heuristics below.
   DEFINE_STATIC_LOCAL(SparseHistogram, callbackBufferSizeHistogram,
                       ("WebAudio.AudioDestination.CallbackBufferSize"));
 
-  // Use the optimal buffer size recommended by the audio backend.
-  size_t recommendedHardwareBufferSize =
-      Platform::current()->audioHardwareBufferSize();
-  m_callbackBufferSize = recommendedHardwareBufferSize;
+  m_audioDevice = wrapUnique(Platform::current()->createAudioDevice(
+      numberOfInputChannels, numberOfOutputChannels, latencyHint, this,
+      inputDeviceId, std::move(securityOrigin)));
+  DCHECK(m_audioDevice);
 
-#if OS(ANDROID)
-  // The optimum low-latency hardware buffer size is usually too small on
-  // Android for WebAudio to render without glitching. So, if it is small, use
-  // a larger size. If it was already large, use the requested size.
-  //
-  // Since WebAudio renders in 128-frame blocks, the small buffer sizes (144
-  // for a Galaxy Nexus), cause significant processing jitter. Sometimes
-  // multiple blocks will processed, but other times will not be since the FIFO
-  // can satisfy the request. By using a larger callbackBufferSize, we smooth
-  // out the jitter.
-  const size_t kSmallBufferSize = 1024;
-  const size_t kDefaultCallbackBufferSize = 2048;
-
-  if (m_callbackBufferSize <= kSmallBufferSize)
-    m_callbackBufferSize = kDefaultCallbackBufferSize;
-#endif
-
+  m_callbackBufferSize = m_audioDevice->framesPerBuffer();
   // Quick exit if the requested size is too large.
   DCHECK_LE(m_callbackBufferSize + AudioUtilities::kRenderQuantumFrames,
             fifoSize);
   if (m_callbackBufferSize + AudioUtilities::kRenderQuantumFrames > fifoSize)
     return;
 
-  m_audioDevice = wrapUnique(Platform::current()->createAudioDevice(
-      m_callbackBufferSize, numberOfInputChannels, numberOfOutputChannels,
-      sampleRate, this, inputDeviceId, std::move(securityOrigin)));
-  ASSERT(m_audioDevice);
-
   // Record the sizes if we successfully created an output device.
-  hardwareBufferSizeHistogram.sample(recommendedHardwareBufferSize);
+  hardwareBufferSizeHistogram.sample(m_callbackBufferSize);

[o1ka, 2016/11/30 11:46:26]

rtoy@/hongchan@ what is your recommendation for these histograms?
What exactly does WebAudio register in them?
They may need to be moved to WebAudioDeviceImpl.

[Raymond Toy, 2016/11/30 20:37:29]

We do definitely want to keep these around.  They're pretty important to
understand what kind of Android devices are out there;  there seems to be much
less variation in desktop values.

[Andrew MacPherson, 2016/12/01 12:11:56]

Should I move these to the WebAudioDeviceImpl then?

[Andrew MacPherson, 2016/12/02 09:42:55]

Maybe for now the easiest thing is to just use the
Platform::audioHardwareBufferSize() here as before and this can be updated in a
subsequent CL where audioHardwareBufferSize() is removed entirely? I've updated
the code to do this now.

[Raymond Toy, 2016/12/02 16:57:45]

If this preserves the current values, then I'm fine with it. I just would prefer
not to see a (short) glitch in the stats.

   callbackBufferSizeHistogram.sample(m_callbackBufferSize);
 
   // Create a FIFO to handle the possibility of the callback size
   // not being a multiple of the render size. If the FIFO already
   // contains enough data, the data will be provided directly.
   // Otherwise, the FIFO will call the provider enough times to
   // satisfy the request for data.
   m_fifo = wrapUnique(new AudioPullFIFO(*this, numberOfOutputChannels, fifoSize,
                                         AudioUtilities::kRenderQuantumFrames));
 
@@ skipping 71 matching lines @@
   AudioBus* sourceBus = nullptr;
   if (m_inputFifo->framesInFifo() >= framesToProcess) {
     m_inputFifo->consume(m_inputBus.get(), framesToProcess);
     sourceBus = m_inputBus.get();
   }
 
   m_callback.render(sourceBus, bus, framesToProcess);
 }
 
 }  // namespace blink