Add WebThread in AudioDestination to support AudioWorkletThread

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 11 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/audio/AudioDestination.h"
 
 #include <memory>
+#include "platform/CrossThreadFunctional.h"
 #include "platform/Histogram.h"
+#include "platform/WebTaskRunner.h"
 #include "platform/audio/AudioUtilities.h"
 #include "platform/audio/PushPullFIFO.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioLatencyHint.h"
 #include "public/platform/WebSecurityOrigin.h"
+#include "public/platform/WebThread.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 // FIFO Size.
 //
 // TODO(hongchan): This was estimated based on the largest callback buffer size
 // that we would ever need. The current UMA stats indicates that this is, in
 // fact, probably too small. There are Android devices out there with a size of
 // 8000 or so.  We might need to make this larger. See: crbug.com/670747
@@ skipping 17 matching lines @@
       m_isPlaying(false),
       m_callback(callback),
       m_outputBus(AudioBus::create(numberOfOutputChannels,
                                    AudioUtilities::kRenderQuantumFrames,
                                    false)),
       m_renderBus(AudioBus::create(numberOfOutputChannels,
                                    AudioUtilities::kRenderQuantumFrames)),
       m_fifo(
           WTF::wrapUnique(new PushPullFIFO(numberOfOutputChannels, kFIFOSize))),
       m_framesElapsed(0) {
+  // Create a thread |WebThread| for WebAudio graph rendering.
+  m_renderingThread = WTF::wrapUnique(
+      Platform::current()->createThread("WebAudio Rendering Thread"));
+
   // Create WebAudioDevice. blink::WebAudioDevice is designed to support the
   // local input (e.g. loopback from OS audio system), but Chromium's media
   // renderer does not support it currently. Thus, we use zero for the number
   // of input channels.
   m_webAudioDevice = WTF::wrapUnique(Platform::current()->createAudioDevice(
       0, numberOfOutputChannels, latencyHint, this, String(),
       std::move(securityOrigin)));
   DCHECK(m_webAudioDevice);
 
   m_callbackBufferSize = m_webAudioDevice->framesPerBuffer();
@@ skipping 13 matching lines @@
                               size_t priorFramesSkipped) {
   CHECK_EQ(destinationData.size(), m_numberOfOutputChannels);
   CHECK_EQ(numberOfFrames, m_callbackBufferSize);
 
   // Note that this method is called by AudioDeviceThread. If FIFO is not ready,
   // or the requested render size is greater than FIFO size return here.
   // (crbug.com/692423)
   if (!m_fifo || m_fifo->length() < numberOfFrames)
     return;
 
+  // Associate the destination data array with the output bus then fill the
+  // FIFO.
+  for (unsigned i = 0; i < m_numberOfOutputChannels; ++i)
+    m_outputBus->setChannelMemory(i, destinationData[i], numberOfFrames);
+
+  m_renderingThread->getWebTaskRunner()->postTask(
+      BLINK_FROM_HERE,
+      crossThreadBind(&AudioDestination::requestRenderOnWebThread,
+                      crossThreadUnretained(this), numberOfFrames, delay,
+                      delayTimestamp, priorFramesSkipped));

[o1ka, 2017/03/29 09:05:11]

See the comment below: I would redesign the fifo to calculate how much data
needs to be renderer and to post the request to render - all this in the
m_fifo->pull()

[hongchan, 2017/03/29 19:39:58]

Hmm. This is a rather big change and different from what we discussed in the
design doc. Could you clarify your proposal?

How can m_fifo_pull() have all this when "this" is a part of AudioDestination?

+
+  m_fifo->pull(m_outputBus.get(), numberOfFrames);

[haraken, 2017/03/29 07:56:24]

Is it okay to pull the result before requestRenderOnWebThread has completed?

[hongchan, 2017/03/29 19:39:58]

Yes. Then the result of pulling is going to be silent and it's a valid
operation. If we enforce the order of rendering procedure, then the lock should
be applied at the level of AudioDestination. In order to avoid it, I put the
lock in the FIFO to minimize the scope of lock.

+}
+
+void AudioDestination::requestRenderOnWebThread(size_t numberOfFrames,
+                                                double delay,
+                                                double delayTimestamp,
+                                                size_t priorFramesSkipped) {
   m_framesElapsed -= std::min(m_framesElapsed, priorFramesSkipped);
   double outputPosition =
       m_framesElapsed / static_cast<double>(m_webAudioDevice->sampleRate()) -
       delay;
   m_outputPosition.position = outputPosition;
   m_outputPosition.timestamp = delayTimestamp;
   m_outputPositionReceivedTimestamp = base::TimeTicks::Now();

[o1ka, 2017/03/29 09:05:11]

Have you considered encapsulating all these Web-thread only members in some
class? Otherwise, it's hard to make sure that they are never access from a wrong
thread.

[hongchan, 2017/03/29 19:39:58]

I tried to have a clear separation between render() and
requestRenderOnWebThread(). All the timestamp stuffs are being accessed only in
this method. Do you think this is not good enough?

 
-  // Associate the destination data array with the output bus then fill the
-  // FIFO.
-  for (unsigned i = 0; i < m_numberOfOutputChannels; ++i)
-    m_outputBus->setChannelMemory(i, destinationData[i], numberOfFrames);
-
   // Number of frames to render via WebAudio graph. |framesToRender > 0| means
   // the frames in FIFO is not enough to fulfill the requested frames from the
   // audio device.
   size_t framesToRender = numberOfFrames > m_fifo->framesAvailable()

[o1ka, 2017/03/29 09:05:11]

framesAvailable() is not thread safe.

[hongchan, 2017/03/29 19:39:58]

Based on our conversation, I thought this was okay. Of course I can put a lock
around the getter.

https://docs.google.com/document/d/1WnqZHcA2TQjS1aKvzx2nnJ2y2tWK1Xp_0BhFGpsry...

                               ? numberOfFrames - m_fifo->framesAvailable()
                               : 0;
 
   for (size_t pushedFrames = 0; pushedFrames < framesToRender;
        pushedFrames += AudioUtilities::kRenderQuantumFrames) {
     // If platform buffer is more than two times longer than |framesToProcess|
     // we do not want output position to get stuck so we promote it
     // using the elapsed time from the moment it was initially obtained.
     if (m_callbackBufferSize > AudioUtilities::kRenderQuantumFrames * 2) {
       double delta =
           (base::TimeTicks::Now() - m_outputPositionReceivedTimestamp)
               .InSecondsF();
       m_outputPosition.position += delta;
       m_outputPosition.timestamp += delta;
     }
 
     // Some implementations give only rough estimation of |delay| so
     // we might have negative estimation |outputPosition| value.
     if (m_outputPosition.position < 0.0)
       m_outputPosition.position = 0.0;
 
     // Process WebAudio graph and push the rendered output to FIFO.
     m_callback.render(nullptr, m_renderBus.get(),
                       AudioUtilities::kRenderQuantumFrames, m_outputPosition);
     m_fifo->push(m_renderBus.get());
   }
 
-  m_fifo->pull(m_outputBus.get(), numberOfFrames);
-
   m_framesElapsed += numberOfFrames;
 }
 
 void AudioDestination::start() {
   if (m_webAudioDevice && !m_isPlaying) {
     m_webAudioDevice->start();
     m_isPlaying = true;
   }
 }
 
@@ skipping 33 matching lines @@
   callbackBufferSizeHistogram.sample(m_callbackBufferSize);
 
   // Check if the requested buffer size is too large.
   bool isBufferSizeValid =
       m_callbackBufferSize + AudioUtilities::kRenderQuantumFrames <= kFIFOSize;
   DCHECK(isBufferSizeValid);
   return isBufferSizeValid;
 }
 
 }  // namespace blink