Add WebThread in AudioDestination to support AudioWorkletThread

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

 // Copyright 2017 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 "platform/audio/PushPullFIFO.h"
 
 #include <memory>
 #include "platform/audio/AudioUtilities.h"
 #include "platform/wtf/PtrUtil.h"
 
@@ skipping 16 matching lines @@
       underflow_count_(0) {
   CHECK_LE(fifo_length_, kMaxFIFOLength);
   fifo_bus_ = AudioBus::Create(number_of_channels, fifo_length_);
 }
 
 PushPullFIFO::~PushPullFIFO() {}
 
 // Push the data from |inputBus| to FIFO. The size of push is determined by
 // the length of |inputBus|.
 void PushPullFIFO::Push(const AudioBus* input_bus) {
+  MutexLocker locker(lock_);
+
   CHECK(input_bus);
   CHECK_EQ(input_bus->length(), AudioUtilities::kRenderQuantumFrames);
   SECURITY_CHECK(input_bus->length() <= fifo_length_);
   SECURITY_CHECK(index_write_ < fifo_length_);
 
   const size_t input_bus_length = input_bus->length();
   const size_t remainder = fifo_length_ - index_write_;
 
   for (unsigned i = 0; i < fifo_bus_->NumberOfChannels(); ++i) {
     float* fifo_bus_channel = fifo_bus_->Channel(i)->MutableData();
@@ skipping 28 matching lines @@
   }
 
   // Update the number of frames available in FIFO.
   frames_available_ =
       std::min(frames_available_ + input_bus_length, fifo_length_);
   DCHECK_EQ((index_read_ + frames_available_) % fifo_length_, index_write_);
 }
 
 // Pull the data out of FIFO to |outputBus|. If remaining frame in the FIFO
 // is less than the frames to pull, provides remaining frame plus the silence.
-void PushPullFIFO::Pull(AudioBus* output_bus, size_t frames_requested) {
+void PushPullFIFO::Pull(
+    AudioBus* output_bus,
+    size_t frames_requested,
+    std::unique_ptr<WTF::Function<void(size_t, size_t)>>
+        push_request_render_callback) {
 #if OS(ANDROID)
   if (!output_bus) {
     // Log when outputBus or FIFO object is invalid. (crbug.com/692423)
     LOG(WARNING) << "[WebAudio/PushPullFIFO::pull <" << static_cast<void*>(this)
                  << ">] |outputBus| is invalid.";
     // Silently return to avoid crash.

[nhiroki, 2017/04/17 03:27:30]

Generally, I'd recommend to run the callback on all return paths (w/ some status
code) so that the caller can have a chance to release resources.

[hongchan, 2017/04/17 16:03:29]

A good point. I missed that.

     return;
   }
 
   // The following checks are in place to catch the inexplicable crash.
   // (crbug.com/692423)
   if (frames_requested > output_bus->length()) {
     LOG(WARNING) << "[WebAudio/PushPullFIFO::pull <" << static_cast<void*>(this)
                  << ">] framesRequested > outputBus->length() ("
                  << frames_requested << " > " << output_bus->length() << ")";
   }
   if (frames_requested > fifo_length_) {
     LOG(WARNING) << "[WebAudio/PushPullFIFO::pull <" << static_cast<void*>(this)
                  << ">] framesRequested > m_fifoLength (" << frames_requested
                  << " > " << fifo_length_ << ")";
   }
   if (index_read_ >= fifo_length_) {
     LOG(WARNING) << "[WebAudio/PushPullFIFO::pull <" << static_cast<void*>(this)
                  << ">] m_indexRead >= m_fifoLength (" << index_read_
                  << " >= " << fifo_length_ << ")";
   }
 #endif
+
+  MutexLocker locker(lock_);
+
   CHECK(output_bus);
   SECURITY_CHECK(frames_requested <= output_bus->length());
   SECURITY_CHECK(frames_requested <= fifo_length_);
   SECURITY_CHECK(index_read_ < fifo_length_);
 
   const size_t remainder = fifo_length_ - index_read_;
   const size_t frames_to_fill = std::min(frames_available_, frames_requested);
 
   for (unsigned i = 0; i < fifo_bus_->NumberOfChannels(); ++i) {
     const float* fifo_bus_channel = fifo_bus_->Channel(i)->Data();
@@ skipping 32 matching lines @@
                    << "underflowCount=" << underflow_count_
                    << ", availableFrames=" << frames_available_
                    << ", requestedFrames=" << frames_requested
                    << ", fifoLength=" << fifo_length_ << ")";
     }
   }
 
   // Update the number of frames in FIFO.
   frames_available_ -= frames_to_fill;
   DCHECK_EQ((index_read_ + frames_available_) % fifo_length_, index_write_);
+
+  // 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 frames_to_render = frames_requested > frames_available_
+                                ? frames_requested - frames_available_
+                                : 0;
+
+  if (frames_to_render > 0)
+    (*push_request_render_callback)(frames_requested, frames_to_render);

[nhiroki, 2017/04/17 03:27:30]

This callback is called within the mutex section (see line 120). That could be
risky, for example, some callback may wrongly call PushPullFIFO::Pull() again.

If |frames_requested| is never modified in this function and |frames_to_render|
is the only real return value, how about just returning |frames_to_render|
instead of calling a given callback?

[hongchan, 2017/04/17 16:03:29]

Actually that'd be cleaner than what I have here. I would like to know how olka@
think about this.

 }
 
 const PushPullFIFOStateForTest PushPullFIFO::GetStateForTest() const {
-  return {length(),     NumberOfChannels(), FramesAvailable(), index_read_,
+  return {length(),     NumberOfChannels(), frames_available_, index_read_,
           index_write_, overflow_count_,    underflow_count_};
 }
 
 }  // namespace blink