Refactor AudioRendererMixer to be more generic.

media/base/audio_converter.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 "media/base/audio_converter.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 93 matching lines @@
     Reset();
 }
 
 void AudioConverter::Reset() {
   if (audio_fifo_)
     audio_fifo_->Clear();
   if (resampler_)
     resampler_->Flush();
 }
 
-void AudioConverter::Convert(AudioBus* dest) {
+void AudioConverter::ConvertWithDelay(base::TimeDelta initial_delay,

[no longer working on chromium, 2013/04/30 08:42:23]

nit, const base::TimeDelta& ?

+                                      AudioBus* dest) {
+  initial_delay_ = initial_delay;
+
   if (transform_inputs_.empty()) {
     dest->Zero();
     return;
   }
 
   bool needs_mixing = channel_mixer_ && !downmix_early_;
   AudioBus* temp_dest = needs_mixing ? unmixed_audio_.get() : dest;
   DCHECK(temp_dest);
 
   if (!resampler_ && !audio_fifo_) {
     SourceCallback(0, temp_dest);
   } else {
     if (resampler_)
       resampler_->Resample(temp_dest, temp_dest->frames());
     else
       ProvideInput(0, temp_dest);
   }
 
   if (needs_mixing) {
     DCHECK_EQ(temp_dest->frames(), dest->frames());
     channel_mixer_->Transform(temp_dest, dest);
   }
 }
 
+void AudioConverter::Convert(AudioBus* dest) {
+  ConvertWithDelay(base::TimeDelta::FromMilliseconds(0), dest);
+}
+
 void AudioConverter::SourceCallback(int fifo_frame_delay, AudioBus* dest) {
   bool needs_downmix = channel_mixer_ && downmix_early_;
 
   if (!mixer_input_audio_bus_ ||
       mixer_input_audio_bus_->frames() != dest->frames()) {
     mixer_input_audio_bus_ =
         AudioBus::Create(input_channel_count_, dest->frames());
   }
 
   if (needs_downmix &&
       (!unmixed_audio_ || unmixed_audio_->frames() != dest->frames())) {
     // If we're downmixing early we need a temporary AudioBus which matches
     // the the input channel count and input frame size since we're passing
     // |unmixed_audio_| directly to the |source_callback_|.
     unmixed_audio_ = AudioBus::Create(input_channel_count_, dest->frames());
   }
 
   AudioBus* temp_dest = needs_downmix ? unmixed_audio_.get() : dest;
 
   // Sanity check our inputs.
   DCHECK_EQ(temp_dest->frames(), mixer_input_audio_bus_->frames());
   DCHECK_EQ(temp_dest->channels(), mixer_input_audio_bus_->channels());
 
   // Calculate the buffer delay for this callback.
-  base::TimeDelta buffer_delay;
+  base::TimeDelta buffer_delay = initial_delay_;
   if (resampler_) {
     buffer_delay += base::TimeDelta::FromMicroseconds(
         resampler_frame_delay_ * output_frame_duration_.InMicroseconds());
   }
   if (audio_fifo_) {
     buffer_delay += base::TimeDelta::FromMicroseconds(
         fifo_frame_delay * input_frame_duration_.InMicroseconds());
   }
 
   // Have each mixer render its data into an output buffer then mix the result.
@@ skipping 40 matching lines @@
 
 void AudioConverter::ProvideInput(int resampler_frame_delay, AudioBus* dest) {
   resampler_frame_delay_ = resampler_frame_delay;
   if (audio_fifo_)
     audio_fifo_->Consume(dest, dest->frames());
   else
     SourceCallback(0, dest);
 }
 
 }  // namespace media