Switch AudioRenderSink::Callback to use AudioBus.

media/base/audio_renderer_mixer.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_renderer_mixer.h"
 
 #if defined(ARCH_CPU_X86_FAMILY) && defined(__SSE__)
 #include <xmmintrin.h>
 #endif
 
@@ skipping 28 matching lines @@
   }
 
   audio_sink_->Initialize(output_params, this);
   audio_sink_->Start();
 }
 
 AudioRendererMixer::~AudioRendererMixer() {
   // AudioRendererSinks must be stopped before being destructed.
   audio_sink_->Stop();
 
-  // Clean up |mixer_input_audio_data_|.
-  for (size_t i = 0; i < mixer_input_audio_data_.size(); ++i)
-    base::AlignedFree(mixer_input_audio_data_[i]);
-  mixer_input_audio_data_.clear();
-
   // Ensures that all mixer inputs have stopped themselves prior to destruction
   // and have called RemoveMixerInput().
   DCHECK_EQ(mixer_inputs_.size(), 0U);
 }
 
 void AudioRendererMixer::AddMixerInput(
     const scoped_refptr<AudioRendererMixerInput>& input) {
   base::AutoLock auto_lock(mixer_inputs_lock_);
   mixer_inputs_.insert(input);
 }
 
 void AudioRendererMixer::RemoveMixerInput(
     const scoped_refptr<AudioRendererMixerInput>& input) {
   base::AutoLock auto_lock(mixer_inputs_lock_);
   mixer_inputs_.erase(input);
 }
 
-int AudioRendererMixer::Render(const std::vector<float*>& audio_data,
+int AudioRendererMixer::Render(AudioBus* audio_bus,
                                int number_of_frames,
                                int audio_delay_milliseconds) {
   current_audio_delay_milliseconds_ = audio_delay_milliseconds;
 
   if (resampler_.get())
-    resampler_->Resample(audio_data, number_of_frames);
+    resampler_->Resample(audio_bus, number_of_frames);
   else
-    ProvideInput(audio_data, number_of_frames);
+    ProvideInput(audio_bus, number_of_frames);
 
   // Always return the full number of frames requested, ProvideInput() will pad
   // with silence if it wasn't able to acquire enough data.
   return number_of_frames;
 }
 
-void AudioRendererMixer::ProvideInput(const std::vector<float*>& audio_data,
+void AudioRendererMixer::ProvideInput(AudioBus* audio_bus,
                                       int number_of_frames) {
   base::AutoLock auto_lock(mixer_inputs_lock_);
 
   // Allocate staging area for each mixer input's audio data on first call.  We
   // won't know how much to allocate until here because of resampling.
-  if (mixer_input_audio_data_.size() == 0) {
-    mixer_input_audio_data_.reserve(audio_data.size());
-    for (size_t i = 0; i < audio_data.size(); ++i) {
-      // Allocate audio data with a 16-byte alignment for SSE optimizations.
-      mixer_input_audio_data_.push_back(static_cast<float*>(
-          base::AlignedAlloc(sizeof(float) * number_of_frames, 16)));
-    }
-    mixer_input_audio_data_size_ = number_of_frames;
+  if (!mixer_input_audio_bus_.get()) {
+    mixer_input_audio_bus_ =
+        AudioBus::Create(audio_bus->channels(), number_of_frames);
   }
 
   // Sanity check our inputs.
-  DCHECK_LE(number_of_frames, mixer_input_audio_data_size_);
-  DCHECK_EQ(audio_data.size(), mixer_input_audio_data_.size());
+  DCHECK_LE(number_of_frames, audio_bus->frames());
+  DCHECK_LE(number_of_frames, mixer_input_audio_bus_->frames());
+  DCHECK_EQ(audio_bus->channels(), mixer_input_audio_bus_->channels());
 
-  // Zero |audio_data| so we're mixing into a clean buffer and return silence if
+  // Zero |audio_bus| so we're mixing into a clean buffer and return silence if
   // we couldn't get enough data from our inputs.
-  for (size_t i = 0; i < audio_data.size(); ++i)
-    memset(audio_data[i], 0, number_of_frames * sizeof(*audio_data[i]));
+  audio_bus->ZeroFrames(number_of_frames);
 
   // Have each mixer render its data into an output buffer then mix the result.
   for (AudioRendererMixerInputSet::iterator it = mixer_inputs_.begin();
        it != mixer_inputs_.end(); ++it) {
     const scoped_refptr<AudioRendererMixerInput>& input = *it;
 
     double volume;
     input->GetVolume(&volume);
 
     // Nothing to do if the input isn't playing.
     if (!input->playing())
       continue;
 
     int frames_filled = input->callback()->Render(
-        mixer_input_audio_data_, number_of_frames,
+        mixer_input_audio_bus_.get(), number_of_frames,
         current_audio_delay_milliseconds_);
     if (frames_filled == 0)
       continue;
 
-    // Volume adjust and mix each mixer input into |audio_data| after rendering.
-    for (size_t j = 0; j < audio_data.size(); ++j) {
-       VectorFMAC(
-           mixer_input_audio_data_[j], volume, frames_filled, audio_data[j]);
+    // Volume adjust and mix each mixer input into |audio_bus| after rendering.
+    for (int i = 0; i < audio_bus->channels(); ++i) {
+       VectorFMAC(mixer_input_audio_bus_->channel(i), volume, frames_filled,
+                  audio_bus->channel(i));
     }
 
     // No need to clamp values as InterleaveFloatToInt() will take care of this
     // for us later when data is transferred to the browser process.
   }
 }
 
 void AudioRendererMixer::OnRenderError() {
   base::AutoLock auto_lock(mixer_inputs_lock_);
 
@@ skipping 40 matching lines @@
                  _mm_mul_ps(_mm_load_ps(src + i), m_scale)));
   }
 
   // Handle any remaining values that wouldn't fit in an SSE pass.
   if (rem)
     VectorFMAC_C(src + len - rem, scale, rem, dest + len - rem);
 }
 #endif
 
 }  // namespace media