Moving FIFO from AudioDestination to RendererWebAudioDeviceImpl

content/renderer/media/renderer_webaudiodevice_impl.cc

 // Copyright (c) 2012 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 "content/renderer/media/renderer_webaudiodevice_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/audio/null_audio_sink.h"
+#include "media/base/audio_pull_fifo.h"
 #include "media/base/media_switches.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 using blink::WebAudioDevice;
 using blink::WebLocalFrame;
 using blink::WebVector;
 using blink::WebView;
 
+namespace {
+
+int CalculateRenderBufferSizer(int default_sink_frames_per_buffer) {
+#if defined(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.
+  //
+  // 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 WebAudio can't
+  // satisfy the request. By using a larger render buffer size, we smooth out
+  // the jitter.
+  const int kSmallBufferSize = 1024;
+  const int kDefaultCallbackBufferSize = 2048;
+  if (default_sink_frames_per_buffer <= kSmallBufferSize)
+    return kDefaultCallbackBufferSize;
+#endif
+
+  return default_sink_frames_per_buffer;
+}
+
+}  // namespace
+
 namespace content {
 
 #if defined(OS_ANDROID)
 static const int kSilenceInSecondsToEnterIdleMode = 30;
 #endif
 
 RendererWebAudioDeviceImpl::RendererWebAudioDeviceImpl(
     const media::AudioParameters& params,
     WebAudioDevice::RenderCallback* callback,
     int session_id,
     const url::Origin& security_origin)
-    : params_(params),
+    : client_params_(params),
       client_callback_(callback),
       session_id_(session_id),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       null_audio_sink_(new media::NullAudioSink(task_runner_)),
       is_using_null_audio_sink_(false),
-      first_buffer_after_silence_(media::AudioBus::Create(params_)),
+      first_buffer_after_silence_(media::AudioBus::Create(client_params_)),
       is_first_buffer_after_silence_(false),
       security_origin_(security_origin) {
   DCHECK(client_callback_);
-  null_audio_sink_->Initialize(params_, this);
-  null_audio_sink_->Start();
 }
 
 RendererWebAudioDeviceImpl::~RendererWebAudioDeviceImpl() {
   DCHECK(!sink_);
 }
 
 void RendererWebAudioDeviceImpl::start() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (sink_)
     return;  // Already started.
 
   // Assumption: This method is being invoked within a V8 call stack.  CHECKs
   // will fail in the call to frameForCurrentContext() otherwise.
   //
   // Therefore, we can perform look-ups to determine which RenderView is
   // starting the audio device.  The reason for all this is because the creator
   // of the WebAudio objects might not be the actual source of the audio (e.g.,
   // an extension creates a object that is passed and used within a page).
   WebLocalFrame* const web_frame = WebLocalFrame::frameForCurrentContext();
   RenderFrame* const render_frame =
       web_frame ? RenderFrame::FromWebFrame(web_frame) : NULL;
   sink_ = AudioDeviceFactory::NewAudioRendererSink(
       AudioDeviceFactory::kSourceWebAudio,
       render_frame ? render_frame->GetRoutingID() : MSG_ROUTING_NONE,
       session_id_, std::string(), security_origin_);
-  sink_->Initialize(params_, this);
+
+  // Output basing on default sink buffer size.
+  media::AudioParameters output_params(client_params_);
+  output_params.set_frames_per_buffer(CalculateRenderBufferSizer(
+      sink_->GetOutputDeviceInfo().output_params().frames_per_buffer()));
+
+  CreateFifoIfRequired(output_params.frames_per_buffer());
+
+  null_audio_sink_->Initialize(output_params, this);
+  null_audio_sink_->Start();
+  start_null_audio_sink_callback_.Reset(
+      base::Bind(&media::NullAudioSink::Play, null_audio_sink_));

[hongchan, 2016/05/26 16:43:33]

I am ignorant on the renderer code, but why do we need null_audio_sink?

[o1ka, 2016/05/26 16:47:47]

It was introduce in this CL https://codereview.chromium.org/1195633003, to safe
some power on Android.

+
+  sink_->Initialize(output_params, this);
   sink_->Start();
   sink_->Play();
-  start_null_audio_sink_callback_.Reset(
-      base::Bind(&media::NullAudioSink::Play, null_audio_sink_));
   // Note: Default behavior is to auto-play on start.
 }
 
 void RendererWebAudioDeviceImpl::stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (sink_) {
     sink_->Stop();
     sink_ = NULL;
   }
   null_audio_sink_->Stop();
   is_using_null_audio_sink_ = false;
   is_first_buffer_after_silence_ = false;
   start_null_audio_sink_callback_.Cancel();
 }
 
 double RendererWebAudioDeviceImpl::sampleRate() {
-  return params_.sample_rate();
+  return client_params_.sample_rate();
 }
 
 int RendererWebAudioDeviceImpl::Render(media::AudioBus* dest,
                                        uint32_t frames_delayed,
                                        uint32_t frames_skipped) {
 #if defined(OS_ANDROID)
+  // There can be a race in Render() on Android (https://crbug.com/614978), so
+  // don't try to inject the FIFO dynamically, just rely on the initialization.
+  DCHECK(audio_fifo_ || (dest->frames() == client_params_.frames_per_buffer()));
+#else
+  // Allow Render() to work on varying buffer size.
+  CreateFifoIfRequired(dest->frames());
+#endif
+
+  if (audio_fifo_)
+    audio_fifo_->Consume(dest, dest->frames());
+  else
+    SourceCallback(0, dest);
+
+  return dest->frames();
+}
+
+void RendererWebAudioDeviceImpl::SourceCallback(int fifo_frame_delay,
+                                                media::AudioBus* dest) {
+#if defined(OS_ANDROID)
   if (is_first_buffer_after_silence_) {
     DCHECK(!is_using_null_audio_sink_);
     first_buffer_after_silence_->CopyTo(dest);
     is_first_buffer_after_silence_ = false;
-    return dest->frames();
+    return;
   }
 #endif
   // Wrap the output pointers using WebVector.
   WebVector<float*> web_audio_dest_data(
       static_cast<size_t>(dest->channels()));
   for (int i = 0; i < dest->channels(); ++i)
     web_audio_dest_data[i] = dest->channel(i);
 
   // TODO(xians): Remove the following |web_audio_source_data| after
   // changing the blink interface.
@@ skipping 11 matching lines @@
       DCHECK(thread_checker_.CalledOnValidThread());
       is_using_null_audio_sink_ = false;
       is_first_buffer_after_silence_ = true;
       dest->CopyTo(first_buffer_after_silence_.get());
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&media::NullAudioSink::Pause, null_audio_sink_));
       // Calling sink_->Play() may trigger reentrancy into this
       // function, so this should be called at the end.
       sink_->Play();
-      return dest->frames();
+      return;
     }
   } else if (!is_using_null_audio_sink_) {
     // Called on the audio device thread.
     const base::TimeTicks now = base::TimeTicks::Now();
     if (first_silence_time_.is_null())
       first_silence_time_ = now;
     if (now - first_silence_time_
         > base::TimeDelta::FromSeconds(kSilenceInSecondsToEnterIdleMode)) {
       sink_->Pause();
       is_using_null_audio_sink_ = true;
       // If Stop() is called right after the task is posted, need to cancel
       // this task.
-      task_runner_->PostDelayedTask(
-          FROM_HERE,
-          start_null_audio_sink_callback_.callback(),
-          params_.GetBufferDuration());
+      task_runner_->PostDelayedTask(FROM_HERE,
+                                    start_null_audio_sink_callback_.callback(),
+                                    client_params_.GetBufferDuration());
     }
   }
 #endif
-  return dest->frames();
 }
 
 void RendererWebAudioDeviceImpl::OnRenderError() {
   // TODO(crogers): implement error handling.
 }
 
+void RendererWebAudioDeviceImpl::CreateFifoIfRequired(
+    int render_frames_per_buffer) {
+  if (!audio_fifo_ &&
+      render_frames_per_buffer != client_params_.frames_per_buffer()) {
+    audio_fifo_.reset(new media::AudioPullFifo(
+        client_params_.channels(), client_params_.frames_per_buffer(),
+        base::Bind(&RendererWebAudioDeviceImpl::SourceCallback,
+                   base::Unretained(this))));
+    DVLOG(1) << "Client buffer size: " << client_params_.frames_per_buffer()
+             << " output buffer size: " << render_frames_per_buffer
+             << "; fifo injected.";
+  }
+}
+
 }  // namespace content