media::WebAudioSourceProviderImpl, add support for getting a copy of passing AudioBuses

media/blink/webaudiosourceprovider_impl.cc

 // Copyright 2013 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 "media/blink/webaudiosourceprovider_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 35 matching lines @@
 };
 
 }  // namespace
 
 WebAudioSourceProviderImpl::WebAudioSourceProviderImpl(
     const scoped_refptr<RestartableAudioRendererSink>& sink)
     : channels_(0),
       sample_rate_(0),
       volume_(1.0),
       state_(kStopped),
-      renderer_(NULL),
-      client_(NULL),
+      renderer_(nullptr),
+      client_(nullptr),
       sink_(sink),
       weak_factory_(this) {}
 
 WebAudioSourceProviderImpl::~WebAudioSourceProviderImpl() {
 }
 
 void WebAudioSourceProviderImpl::setClient(
     blink::WebAudioSourceProviderClient* client) {
   base::AutoLock auto_lock(sink_lock_);
   if (client && client != client_) {
@@ skipping 40 matching lines @@
   if (!auto_try_lock.locked() || state_ != kPlaying) {
     // Provide silence if we failed to acquire the lock or the source is not
     // running.
     bus_wrapper_->Zero();
     return;
   }
 
   DCHECK(renderer_);
   DCHECK(client_);
   DCHECK_EQ(channels_, bus_wrapper_->channels());
   const int frames = renderer_->Render(bus_wrapper_.get(), 0, 0);

[DaleCurtis, 2016/03/11 01:41:42]

What do you expect to happen in this case?

[mcasas, 2016/03/11 04:06:23]

Done.

   if (frames < static_cast<int>(number_of_frames)) {
     bus_wrapper_->ZeroFramesPartial(
         frames,
         static_cast<int>(number_of_frames - frames));
   }
 
   bus_wrapper_->Scale(volume_);
 }
 
 void WebAudioSourceProviderImpl::Start() {
@@ skipping 36 matching lines @@
   return true;
 }
 
 OutputDevice* WebAudioSourceProviderImpl::GetOutputDevice() {
   base::AutoLock auto_lock(sink_lock_);
   return sink_->GetOutputDevice();
 }
 
 void WebAudioSourceProviderImpl::Initialize(
     const AudioParameters& params,
-    RenderCallback* renderer) {
+    AudioRendererSink::RenderCallback* renderer) {
   base::AutoLock auto_lock(sink_lock_);
+
   renderer_ = renderer;
 
   DCHECK_EQ(state_, kStopped);
-  sink_->Initialize(params, renderer);
+  sink_->Initialize(params, this);  // We act as forwarder to |renderer_|.
 
   // Keep track of the format in case the client hasn't yet been set.
   channels_ = params.channels();
   sample_rate_ = params.sample_rate();
 
   if (!set_format_cb_.is_null())
     base::ResetAndReturn(&set_format_cb_).Run();
 }
 
+int WebAudioSourceProviderImpl::Render(AudioBus* audio_bus,
+                                       uint32_t delay_milliseconds,
+                                       uint32_t frames_skipped) {
+  DCHECK(renderer_);
+  DCHECK(!frames_skipped);

[DaleCurtis, 2016/03/11 01:41:42]

Is this reasonable?

[mcasas, 2016/03/11 04:06:23]

Prob remainder of some test. Removed.

+
+  const int num_rendered_frames =
+      renderer_->Render(audio_bus, delay_milliseconds, frames_skipped);
+
+  if (!onaudiobus_callback_.is_null()) {
+    scoped_ptr<AudioBus> bus_copy =
+        AudioBus::Create(audio_bus->channels(), audio_bus->frames());
+    audio_bus->CopyTo(bus_copy.get());
+    onaudiobus_callback_.Run(std::move(bus_copy), delay_milliseconds);
+  }
+
+  return num_rendered_frames;
+}
+
+void WebAudioSourceProviderImpl::OnRenderError() {
+  DCHECK(renderer_);
+  renderer_->OnRenderError();
+}
+
+void WebAudioSourceProviderImpl::RegisterOnAudioBusCallback(
+    const OnAudioBusCB& callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(onaudiobus_callback_.is_null());
+  onaudiobus_callback_ = callback;
+}
+
+void WebAudioSourceProviderImpl::ResetOnAudioBusCallback() {
+  DCHECK(!onaudiobus_callback_.is_null());
+  onaudiobus_callback_.Reset();
+}
+
 void WebAudioSourceProviderImpl::OnSetFormat() {
   base::AutoLock auto_lock(sink_lock_);
   if (!client_)
     return;
 
   // Inform Blink about the audio stream format.
   client_->setFormat(channels_, sample_rate_);
 }
 
 }  // namespace media