Remove muted_ and playback_rate_ from media::AudioRendererAlgorithm.

media/filters/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 "media/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
@@ skipping 34 matching lines @@
     media::AudioRendererSink* sink,
     ScopedVector<AudioDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     AudioHardwareConfig* hardware_config)
     : task_runner_(task_runner),
       sink_(sink),
       audio_buffer_stream_(new AudioBufferStream(task_runner,
                                                  decoders.Pass(),
                                                  set_decryptor_ready_cb)),
       hardware_config_(hardware_config),
+      playback_rate_(0),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       weak_factory_(this) {
   audio_buffer_stream_->set_splice_observer(base::Bind(
       &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
   audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
 void AudioRendererImpl::StartRendering() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!rendering_);
   rendering_ = true;
 
   base::AutoLock auto_lock(lock_);
   // Wait for an eventual call to SetPlaybackRate() to start rendering.
-  if (algorithm_->playback_rate() == 0) {
+  if (playback_rate_ == 0) {
     DCHECK(!sink_playing_);
     return;
   }
 
   StartRendering_Locked();
 }
 
 void AudioRendererImpl::StartRendering_Locked() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kPlaying);
   DCHECK(!sink_playing_);
-  DCHECK_NE(algorithm_->playback_rate(), 0);
+  DCHECK_NE(playback_rate_, 0);
   lock_.AssertAcquired();
 
   sink_playing_ = true;
 
   base::AutoUnlock auto_unlock(lock_);
   sink_->Play();
 }
 
 void AudioRendererImpl::StopRendering() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(rendering_);
   rendering_ = false;
 
   base::AutoLock auto_lock(lock_);
   // Rendering should have already been stopped with a zero playback rate.
-  if (algorithm_->playback_rate() == 0) {
+  if (playback_rate_ == 0) {
     DCHECK(!sink_playing_);
     return;
   }
 
   StopRendering_Locked();
 }
 
 void AudioRendererImpl::StopRendering_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kPlaying);
@@ skipping 212 matching lines @@
     return;
   }
 
   if (expecting_config_changes_)
     buffer_converter_.reset(new AudioBufferConverter(audio_parameters_));
   splicer_.reset(new AudioSplicer(audio_parameters_.sample_rate()));
 
   // We're all good! Continue initializing the rest of the audio renderer
   // based on the decoder format.
   algorithm_.reset(new AudioRendererAlgorithm());
-  algorithm_->Initialize(0, audio_parameters_);
+  algorithm_->Initialize(audio_parameters_);
 
   ChangeState_Locked(kFlushed);
 
   HistogramRendererEvent(INITIALIZED);
 
   {
     base::AutoUnlock auto_unlock(lock_);
     sink_->Initialize(audio_parameters_, this);
     sink_->Start();
 
@@ skipping 166 matching lines @@
   DVLOG(1) << __FUNCTION__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GE(playback_rate, 0);
   DCHECK(sink_);
 
   base::AutoLock auto_lock(lock_);
 
   // We have two cases here:
   // Play: current_playback_rate == 0 && playback_rate != 0
   // Pause: current_playback_rate != 0 && playback_rate == 0
-  float current_playback_rate = algorithm_->playback_rate();
-  algorithm_->SetPlaybackRate(playback_rate);
+  float current_playback_rate = playback_rate_;
+  playback_rate_ = playback_rate;
 
   if (!rendering_)
     return;
 
   if (current_playback_rate == 0 && playback_rate != 0) {
     StartRendering_Locked();
     return;
   }
 
   if (current_playback_rate != 0 && playback_rate == 0) {
@@ skipping 20 matching lines @@
   base::Closure time_cb;
   {
     base::AutoLock auto_lock(lock_);
 
     // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
     if (!algorithm_) {
       audio_clock_->WroteSilence(requested_frames, delay_frames);
       return 0;
     }
 
-    float playback_rate = algorithm_->playback_rate();
-    if (playback_rate == 0) {
+    if (playback_rate_ == 0) {
       audio_clock_->WroteSilence(requested_frames, delay_frames);
       return 0;
     }
 
     // Mute audio by returning 0 when not playing.
     if (state_ != kPlaying) {
       audio_clock_->WroteSilence(requested_frames, delay_frames);
       return 0;
     }
 
     // We use the following conditions to determine end of playback:
     //   1) Algorithm can not fill the audio callback buffer
     //   2) We received an end of stream buffer
     //   3) We haven't already signalled that we've ended
     //   4) We've played all known audio data sent to hardware
     //
     // We use the following conditions to determine underflow:
     //   1) Algorithm can not fill the audio callback buffer
     //   2) We have NOT received an end of stream buffer
     //   3) We are in the kPlaying state
     //
     // Otherwise the buffer has data we can send to the device.
     const base::TimeDelta media_timestamp_before_filling =
         audio_clock_->CurrentMediaTimestamp(base::TimeDelta());
     if (algorithm_->frames_buffered() > 0) {
-      frames_written = algorithm_->FillBuffer(audio_bus, requested_frames);
+      frames_written =
+          algorithm_->FillBuffer(audio_bus, requested_frames, playback_rate_);
       audio_clock_->WroteAudio(
-          frames_written, delay_frames, playback_rate, algorithm_->GetTime());
+          frames_written, delay_frames, playback_rate_, algorithm_->GetTime());
     }
     audio_clock_->WroteSilence(requested_frames - frames_written, delay_frames);
 
     if (frames_written == 0) {
       if (received_end_of_stream_ && !rendered_end_of_stream_ &&
           audio_clock_->CurrentMediaTimestamp(base::TimeDelta()) ==
               audio_clock_->last_endpoint_timestamp()) {
         rendered_end_of_stream_ = true;
         ended_cb_.Run();
       } else if (!received_end_of_stream_ && state_ == kPlaying) {
@@ skipping 95 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media