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,
                                    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),

[Raymond Toy, 2016/11/15 18:16:17]

Where is this initialized now?  It's really important.

[Andrew MacPherson, 2016/11/16 10:58:30]

Based on an earlier suggestion from o1ka@ I changed it so that the sample rate
is not specified on the Blink side but can instead be queried from the
WebAudioDevice::sampleRate(). It's possible that I have misunderstood though so
let me know if so!

       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);

[hongchan, 2016/11/15 23:46:01]

So I guess now we have to query the sample rate via m_audioDevice. Is this your
intention?

[Andrew MacPherson, 2016/11/16 10:58:29]

Yes, this was the intention but I will let o1ka@ confirm.

 
-#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();

[hongchan, 2016/11/15 23:46:01]

o1ka@

If we do this, is this going to be an IPC call? Similarly, will
|m_audioDevice->sampleRate()| be an IPC call as well?

[o1ka, 2016/11/17 17:37:25]

No extra IPC, the value is cached in audio device. Overall, the change does not
introduce any extra IPC, it just delays a call to fetch device parameters until
audio device is constructed (and thus we can ask for specific device parameters
instead of the default ones)

   // 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/15 22:44:28]

I'm not sure if these two histograms have the right meaning now

[hongchan, 2016/11/15 23:46:01]

I think o1ka is right. This seems wrong and we might have to remove the first
one since we don't have that info in the Blink boundary any more.

[Raymond Toy, 2016/11/15 23:50:38]

Yeah, but I think we really want this somewhere. It's really useful information,
especially on Android, where, I think, we are extremely conservative in the
actual buffer size.  This needs to be optimized more (in a different CL).

[Andrew MacPherson, 2016/11/16 10:58:30]

Let me know if you'd like me to move this elsewhere (to the 'content' side?) or
just remove it entirely and I can take care of that.

   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