Switch the input code to use AudioBlockFifo

content/renderer/media/webrtc_local_audio_renderer.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/webrtc_local_audio_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/audio/audio_output_device.h"
+#include "media/base/audio_block_fifo.h"
 #include "media/base/audio_bus.h"
-#include "media/base/audio_fifo.h"
 
 namespace content {
 
 namespace {
 
 enum LocalRendererSinkStates {
   kSinkStarted = 0,
   kSinkNeverStarted,
   kSinkStatesMax  // Must always be last!
 };
 
 }  // namespace
 
 // media::AudioRendererSink::RenderCallback implementation
 int WebRtcLocalAudioRenderer::Render(
     media::AudioBus* audio_bus, int audio_delay_milliseconds) {
   TRACE_EVENT0("audio", "WebRtcLocalAudioRenderer::Render");
   base::AutoLock auto_lock(thread_lock_);
 
   if (!playing_ || !volume_ || !loopback_fifo_) {
     audio_bus->Zero();
     return 0;
   }
 
   // Provide data by reading from the FIFO if the FIFO contains enough
   // to fulfill the request.
-  if (loopback_fifo_->frames() >= audio_bus->frames()) {
-    loopback_fifo_->Consume(audio_bus, 0, audio_bus->frames());
+  if (loopback_fifo_->available_blocks()) {
+    const media::AudioBus* audio_data = loopback_fifo_->Consume();
+    DCHECK_EQ(audio_data->frames(), audio_bus->frames());
+    audio_data->CopyTo(audio_bus);
   } else {
     audio_bus->Zero();
     // This warning is perfectly safe if it happens for the first audio
     // frames. It should not happen in a steady-state mode.
     DVLOG(2) << "loopback FIFO is empty";
   }
 
   return audio_bus->frames();
 }
 
 void WebRtcLocalAudioRenderer::OnRenderError() {
   NOTIMPLEMENTED();
 }
 
 // content::MediaStreamAudioSink implementation
 void WebRtcLocalAudioRenderer::OnData(const int16* audio_data,
                                       int sample_rate,
                                       int number_of_channels,
                                       int number_of_frames) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("audio", "WebRtcLocalAudioRenderer::CaptureData");
   base::AutoLock auto_lock(thread_lock_);
   if (!playing_ || !volume_ || !loopback_fifo_)
     return;
 
   // Push captured audio to FIFO so it can be read by a local sink.
-  if (loopback_fifo_->frames() + number_of_frames <=
-      loopback_fifo_->max_frames()) {
-    scoped_ptr<media::AudioBus> audio_source = media::AudioBus::Create(
-        number_of_channels, number_of_frames);
-    audio_source->FromInterleaved(audio_data,
-                                  audio_source->frames(),
-                                  sizeof(audio_data[0]));
-    loopback_fifo_->Push(audio_source.get());
+  if (loopback_fifo_->GetUnfilledFrames() >= number_of_frames) {
+    loopback_fifo_->Push(audio_data, number_of_frames, sizeof(audio_data[0]));
 
     const base::TimeTicks now = base::TimeTicks::Now();
     total_render_time_ += now - last_render_time_;
     last_render_time_ = now;
   } else {
     DVLOG(1) << "FIFO is full";
   }
 }
 
 void WebRtcLocalAudioRenderer::OnSetFormat(
@@ skipping 213 matching lines @@
 
   {
     // TODO(henrika): we could add a more dynamic solution here but I prefer
     // a fixed size combined with bad audio at overflow. The alternative is
     // that we start to build up latency and that can be more difficult to
     // detect. Tests have shown that the FIFO never contains more than 2 or 3
     // audio frames but I have selected a max size of ten buffers just
     // in case since these tests were performed on a 16 core, 64GB Win 7
     // machine. We could also add some sort of error notifier in this area if
     // the FIFO overflows.
-    media::AudioFifo* new_fifo = new media::AudioFifo(
-        params.channels(), 10 * params.frames_per_buffer());
+    const int blocks_of_buffers =
+        10 * params.frames_per_buffer() / sink_params_.frames_per_buffer() + 1;
+    media::AudioBlockFifo* new_fifo = new media::AudioBlockFifo(
+        params.channels(), sink_params_.frames_per_buffer(), blocks_of_buffers);
 
     base::AutoLock auto_lock(thread_lock_);
     loopback_fifo_.reset(new_fifo);
   }
 
   if (!sink_)
     return;  // WebRtcLocalAudioRenderer has not yet been started.
 
   // Stop |sink_| and re-create a new one to be initialized with different audio
   // parameters.  Then, invoke MaybeStartSink() to restart everything again.
   if (sink_started_) {
     sink_->Stop();
     sink_started_ = false;
   }
 
   sink_ = AudioDeviceFactory::NewOutputDevice(source_render_view_id_,
                                               source_render_frame_id_);
   MaybeStartSink();
 }
 
 }  // namespace content