Fix muted audio when playback rate != 1.0 or 0.0

content/renderer/media/audio_renderer_impl.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/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
+#include "content/renderer/media/audio_hardware.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_buffers_state.h"
 #include "media/audio/audio_util.h"
 #include "media/base/filter_host.h"
 
 AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
     : AudioRendererBase(),
       bytes_per_second_(0),
       stopped_(false),
       sink_(sink),
@@ skipping 40 matching lines @@
                                       sample_rate,
                                       bits_per_channel,
                                       0);
 
   bytes_per_second_ = audio_parameters_.GetBytesPerSecond();
 
   DCHECK(sink_.get());
 
   if (!is_initialized_) {
     sink_->Initialize(
-        media::SelectSamplesPerPacket(sample_rate),
+        audio_hardware::GetHighLatencyOutputBufferSize(sample_rate),
         audio_parameters_.channels,
         audio_parameters_.sample_rate,
         audio_parameters_.format,
         this);
 
     sink_->Start();
     is_initialized_ = true;
     return true;
   }
 
@@ skipping 106 matching lines @@
         static_cast<int64>(ceil(request_delay.InMicroseconds() *
                                 GetPlaybackRate())));
   }
 
   uint32 bytes_per_frame =
       audio_parameters_.bits_per_sample * audio_parameters_.channels / 8;
 
   const size_t buf_size = number_of_frames * bytes_per_frame;
   scoped_array<uint8> buf(new uint8[buf_size]);
 
-  uint32 filled = FillBuffer(buf.get(), buf_size, request_delay);
-  DCHECK_LE(filled, buf_size);
-  UpdateEarliestEndTime(filled, request_delay, base::Time::Now());
-
-  uint32 filled_frames = filled / bytes_per_frame;
+  uint32 frames_filled = FillBuffer(buf.get(), number_of_frames, request_delay);
+  uint32 bytes_filled = frames_filled * bytes_per_frame;
+  DCHECK_LE(bytes_filled, buf_size);
+  UpdateEarliestEndTime(bytes_filled, request_delay, base::Time::Now());
 
   // Deinterleave each audio channel.
   int channels = audio_data.size();
   for (int channel_index = 0; channel_index < channels; ++channel_index) {
     media::DeinterleaveAudioChannel(buf.get(),
                                     audio_data[channel_index],
                                     channels,
                                     channel_index,
                                     bytes_per_frame / channels,
-                                    filled_frames);
+                                    frames_filled);
 
     // If FillBuffer() didn't give us enough data then zero out the remainder.
-    if (filled_frames < number_of_frames) {
-      int frames_to_zero = number_of_frames - filled_frames;
-      memset(audio_data[channel_index] + filled_frames,
+    if (frames_filled < number_of_frames) {
+      int frames_to_zero = number_of_frames - frames_filled;
+      memset(audio_data[channel_index] + frames_filled,
              0,
              sizeof(float) * frames_to_zero);
     }
   }
-  return filled_frames;
+  return frames_filled;
 }
 
 void AudioRendererImpl::OnRenderError() {
   host()->DisableAudioRenderer();
 }
 
 void AudioRendererImpl::OnRenderEndOfStream() {
   // TODO(enal): schedule callback instead of polling.
   if (base::Time::Now() >= earliest_end_time_)
     SignalEndOfStream();
 }