Use aligned buffer in the audio mixer.

media/audio/audio_output_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/audio/audio_output_mixer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_util.h"
 
 namespace media {
 
 AudioOutputMixer::AudioOutputMixer(AudioManager* audio_manager,
                                    const AudioParameters& params,
                                    const base::TimeDelta& close_delay)
     : AudioOutputDispatcher(audio_manager, params),
+      mixer_data_(new DecoderBuffer(params_.GetBytesPerBuffer())),

[scherkus (not reviewing), 2012/06/05 16:37:43]

I'm not convinced we should be using DecoderBuffer as a general purpose aligned
memory allocator.

Would src/base/memory/aligned_memory.h work here instead?

       ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)),
       close_timer_(FROM_HERE,
                    close_delay,
                    weak_this_.GetWeakPtr(),
                    &AudioOutputMixer::ClosePhysicalStream),
       pending_bytes_(0) {
-  // TODO(enal): align data.
-  mixer_data_.reset(new uint8[params_.GetBytesPerBuffer()]);
 }
 
 AudioOutputMixer::~AudioOutputMixer() {
 }
 
 bool AudioOutputMixer::OpenStream() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (physical_stream_.get())
     return true;
@@ skipping 160 matching lines @@
       if (volume != 1.0) {
         media::AdjustVolume(actual_dest,
                             actual_size,
                             params_.channels(),
                             bytes_per_sample,
                             volume);
       }
       if (actual_size < max_size)
         memset(dest + actual_size, 0, max_size - actual_size);
       first_stream = false;
-      actual_dest = mixer_data_.get();
+      actual_dest = mixer_data_->GetWritableData();
       actual_total_size = actual_size;
     } else {
       media::MixStreams(dest,
                         actual_dest,
                         actual_size,
                         bytes_per_sample,
                         volume);
       actual_total_size = std::max(actual_size, actual_total_size);
     }
   }
@@ skipping 17 matching lines @@
 }
 
 void AudioOutputMixer::WaitTillDataReady() {
   base::AutoLock lock(lock_);
   for (ProxyMap::iterator it = proxies_.begin(); it != proxies_.end(); ++it) {
     it->second.audio_source_callback->WaitTillDataReady();
   }
 }
 
 }  // namespace media