Fix wrong timing when audio is muted.

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 {
 
+// Align audio data to 64-byte boundary. That is current max AVX can use.
+const size_t kMixerDataAlignment = 64;
+
 AudioOutputMixer::AudioOutputMixer(AudioManager* audio_manager,
                                    const AudioParameters& params,
                                    const base::TimeDelta& close_delay)
     : AudioOutputDispatcher(audio_manager, params),
       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()]);
+  mixer_data_.reset(

[DaleCurtis, 2012/06/04 20:48:12]

Drive by: if you don't mind a 32 byte alignment you could back this with a
DecoderBuffer which uses FFmpeg alignment and does the right thing on say ARM
platforms. Maybe I should have named it AlignedBuffer :)

+      new uint8[params_.GetBytesPerBuffer() + kMixerDataAlignment - 1]);
+  aligned_mixer_data_ = reinterpret_cast<uint8*>(
+      (reinterpret_cast<size_t>(mixer_data_.get()) + kMixerDataAlignment - 1) &
+      ~(kMixerDataAlignment - 1));
 }
 
 AudioOutputMixer::~AudioOutputMixer() {
 }
 
 bool AudioOutputMixer::OpenStream() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (physical_stream_.get())
     return true;
@@ skipping 149 matching lines @@
     // particular proxy stream. Use zero instead.
     uint32 actual_size = proxy_data->audio_source_callback->OnMoreData(
         actual_dest,
         max_size,
         AudioBuffersState(proxy_data->pending_bytes, 0));
     if (actual_size == 0)
       continue;
 
     // No need to mix muted stream.
     double volume = proxy_data->volume;
-    if (volume == 0.0)
-      continue;
 
     // Different handling for first and all subsequent streams.
     if (first_stream) {
       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 = aligned_mixer_data_;
       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