Rename AudioRendererBase and AudioRendererAlgorithmBase

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_base.h"
+#include "media/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "media/base/filter_host.h"
 #include "media/audio/audio_util.h"
 
 namespace media {
 
-AudioRendererBase::AudioRendererBase(media::AudioRendererSink* sink)
+AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
     : state_(kUninitialized),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       bytes_per_frame_(0),
       bytes_per_second_(0),
       stopped_(false),
       sink_(sink),
       is_initialized_(false),
-      read_cb_(base::Bind(&AudioRendererBase::DecodedAudioReady,
+      read_cb_(base::Bind(&AudioRendererImpl::DecodedAudioReady,
                           base::Unretained(this))) {
 }
 
-AudioRendererBase::~AudioRendererBase() {
+AudioRendererImpl::~AudioRendererImpl() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
-void AudioRendererBase::Play(const base::Closure& callback) {
+void AudioRendererImpl::Play(const base::Closure& callback) {
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(kPaused, state_);
     state_ = kPlaying;
     callback.Run();
   }
 
   if (stopped_)
     return;
 
   if (GetPlaybackRate() != 0.0f) {
     DoPlay();
   } else {
     DoPause();
   }
 }
 
-void AudioRendererBase::DoPlay() {
+void AudioRendererImpl::DoPlay() {
   earliest_end_time_ = base::Time::Now();
   DCHECK(sink_.get());
   sink_->Play();
 }
 
-void AudioRendererBase::Pause(const base::Closure& callback) {
+void AudioRendererImpl::Pause(const base::Closure& callback) {
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(state_ == kPlaying || state_ == kUnderflow ||
            state_ == kRebuffering);
     pause_cb_ = callback;
     state_ = kPaused;
 
     // Pause only when we've completed our pending read.
     if (!pending_read_) {
       pause_cb_.Run();
       pause_cb_.Reset();
     }
   }
 
   if (stopped_)
     return;
 
   DoPause();
 }
 
-void AudioRendererBase::DoPause() {
+void AudioRendererImpl::DoPause() {
   DCHECK(sink_.get());
   sink_->Pause(false);
 }
 
-void AudioRendererBase::Flush(const base::Closure& callback) {
+void AudioRendererImpl::Flush(const base::Closure& callback) {
   decoder_->Reset(callback);
 }
 
-void AudioRendererBase::Stop(const base::Closure& callback) {
+void AudioRendererImpl::Stop(const base::Closure& callback) {
   if (!stopped_) {
     DCHECK(sink_.get());
     sink_->Stop();
 
     stopped_ = true;
   }
   {
     base::AutoLock auto_lock(lock_);
     state_ = kStopped;
     algorithm_.reset(NULL);
     time_cb_.Reset();
     underflow_cb_.Reset();
   }
   if (!callback.is_null()) {
     callback.Run();
   }
 }
 
-void AudioRendererBase::Seek(base::TimeDelta time, const PipelineStatusCB& cb) {
+void AudioRendererImpl::Seek(base::TimeDelta time, const PipelineStatusCB& cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPaused, state_);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
   DCHECK(pause_cb_.is_null());
   DCHECK(seek_cb_.is_null());
   state_ = kSeeking;
   seek_cb_ = cb;
   seek_timestamp_ = time;
 
   // Throw away everything and schedule our reads.
   audio_time_buffered_ = base::TimeDelta();
   received_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
 
   // |algorithm_| will request more reads.
   algorithm_->FlushBuffers();
 
   if (stopped_)
     return;
 
   DoSeek();
 }
 
-void AudioRendererBase::DoSeek() {
+void AudioRendererImpl::DoSeek() {
   earliest_end_time_ = base::Time::Now();
 
   // Pause and flush the stream when we seek to a new location.
   sink_->Pause(true);
 }
 
-void AudioRendererBase::Initialize(const scoped_refptr<AudioDecoder>& decoder,
+void AudioRendererImpl::Initialize(const scoped_refptr<AudioDecoder>& decoder,
                                    const PipelineStatusCB& init_cb,
                                    const base::Closure& underflow_cb,
                                    const TimeCB& time_cb) {
   DCHECK(decoder);
   DCHECK(!init_cb.is_null());
   DCHECK(!underflow_cb.is_null());
   DCHECK(!time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
   underflow_cb_ = underflow_cb;
   time_cb_ = time_cb;
 
   // Create a callback so our algorithm can request more reads.
-  base::Closure cb = base::Bind(&AudioRendererBase::ScheduleRead_Locked, this);
+  base::Closure cb = base::Bind(&AudioRendererImpl::ScheduleRead_Locked, this);
 
   // Construct the algorithm.
-  algorithm_.reset(new AudioRendererAlgorithmBase());
+  algorithm_.reset(new AudioRendererAlgorithm());
 
   // Initialize our algorithm with media properties, initial playback rate,
   // and a callback to request more reads from the data source.
   ChannelLayout channel_layout = decoder_->channel_layout();
   int channels = ChannelLayoutToChannelCount(channel_layout);
   int bits_per_channel = decoder_->bits_per_channel();
   int sample_rate = decoder_->samples_per_second();
   // TODO(vrk): Add method to AudioDecoder to compute bytes per frame.
   bytes_per_frame_ = channels * bits_per_channel / 8;
 
@@ skipping 23 matching lines @@
   sink_->Initialize(audio_parameters_, this);
 
   sink_->Start();
   is_initialized_ = true;
 
   // Finally, execute the start callback.
   state_ = kPaused;
   init_cb.Run(PIPELINE_OK);
 }
 
-bool AudioRendererBase::HasEnded() {
+bool AudioRendererImpl::HasEnded() {
   base::AutoLock auto_lock(lock_);
   DCHECK(!rendered_end_of_stream_ || algorithm_->NeedsMoreData());
 
   return received_end_of_stream_ && rendered_end_of_stream_;
 }
 
-void AudioRendererBase::ResumeAfterUnderflow(bool buffer_more_audio) {
+void AudioRendererImpl::ResumeAfterUnderflow(bool buffer_more_audio) {
   base::AutoLock auto_lock(lock_);
   if (state_ == kUnderflow) {
     if (buffer_more_audio)
       algorithm_->IncreaseQueueCapacity();
 
     state_ = kRebuffering;
   }
 }
 
-void AudioRendererBase::SetVolume(float volume) {
+void AudioRendererImpl::SetVolume(float volume) {
   if (stopped_)
     return;
   sink_->SetVolume(volume);
 }
 
-void AudioRendererBase::DecodedAudioReady(scoped_refptr<Buffer> buffer) {
+void AudioRendererImpl::DecodedAudioReady(scoped_refptr<Buffer> buffer) {
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying ||
          state_ == kUnderflow || state_ == kRebuffering || state_ == kStopped);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
   if (buffer && buffer->IsEndOfStream()) {
     received_end_of_stream_ = true;
 
@@ skipping 30 matching lines @@
     case kUnderflow:
     case kRebuffering:
       if (buffer && !buffer->IsEndOfStream())
         algorithm_->EnqueueBuffer(buffer);
       return;
     case kStopped:
       return;
   }
 }
 
-void AudioRendererBase::SignalEndOfStream() {
+void AudioRendererImpl::SignalEndOfStream() {
   DCHECK(received_end_of_stream_);
   if (!rendered_end_of_stream_) {
     rendered_end_of_stream_ = true;
     host()->NotifyEnded();
   }
 }
 
-void AudioRendererBase::ScheduleRead_Locked() {
+void AudioRendererImpl::ScheduleRead_Locked() {
   lock_.AssertAcquired();
   if (pending_read_ || state_ == kPaused)
     return;
   pending_read_ = true;
   decoder_->Read(read_cb_);
 }
 
-void AudioRendererBase::SetPlaybackRate(float playback_rate) {
+void AudioRendererImpl::SetPlaybackRate(float playback_rate) {
   DCHECK_LE(0.0f, playback_rate);
 
   if (!stopped_) {
     // Notify sink of new playback rate.
     sink_->SetPlaybackRate(playback_rate);
 
     // We have two cases here:
     // Play: GetPlaybackRate() == 0.0 && playback_rate != 0.0
     // Pause: GetPlaybackRate() != 0.0 && playback_rate == 0.0
     if (GetPlaybackRate() == 0.0f && playback_rate != 0.0f) {
       DoPlay();
     } else if (GetPlaybackRate() != 0.0f && playback_rate == 0.0f) {
       // Pause is easy, we can always pause.
       DoPause();
     }
   }
 
   base::AutoLock auto_lock(lock_);
   algorithm_->SetPlaybackRate(playback_rate);
 }
 
-float AudioRendererBase::GetPlaybackRate() {
+float AudioRendererImpl::GetPlaybackRate() {
   base::AutoLock auto_lock(lock_);
   return algorithm_->playback_rate();
 }
 
-bool AudioRendererBase::IsBeforeSeekTime(const scoped_refptr<Buffer>& buffer) {
+bool AudioRendererImpl::IsBeforeSeekTime(const scoped_refptr<Buffer>& buffer) {
   return (state_ == kSeeking) && buffer && !buffer->IsEndOfStream() &&
       (buffer->GetTimestamp() + buffer->GetDuration()) < seek_timestamp_;
 }
 
-int AudioRendererBase::Render(const std::vector<float*>& audio_data,
+int AudioRendererImpl::Render(const std::vector<float*>& audio_data,
                               int number_of_frames,
                               int audio_delay_milliseconds) {
   if (stopped_ || GetPlaybackRate() == 0.0f) {
     // Output silence if stopped.
     for (size_t i = 0; i < audio_data.size(); ++i)
       memset(audio_data[i], 0, sizeof(float) * number_of_frames);
     return 0;
   }
 
   // Adjust the playback delay.
@@ skipping 31 matching lines @@
     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 frames_filled;
 }
 
-uint32 AudioRendererBase::FillBuffer(uint8* dest,
+uint32 AudioRendererImpl::FillBuffer(uint8* dest,
                                      uint32 requested_frames,
                                      const base::TimeDelta& playback_delay) {
   // The |audio_time_buffered_| is the ending timestamp of the last frame
   // buffered at the audio device. |playback_delay| is the amount of time
   // buffered at the audio device. The current time can be computed by their
   // difference.
   base::TimeDelta current_time = audio_time_buffered_ - playback_delay;
 
   size_t frames_written = 0;
   base::Closure underflow_cb;
@@ skipping 56 matching lines @@
        current_time > host()->GetTime())) {
     time_cb_.Run(current_time, audio_time_buffered_);
   }
 
   if (!underflow_cb.is_null())
     underflow_cb.Run();
 
   return frames_written;
 }
 
-void AudioRendererBase::UpdateEarliestEndTime(int bytes_filled,
+void AudioRendererImpl::UpdateEarliestEndTime(int bytes_filled,
                                               base::TimeDelta request_delay,
                                               base::Time time_now) {
   if (bytes_filled != 0) {
     base::TimeDelta predicted_play_time = ConvertToDuration(bytes_filled);
     float playback_rate = GetPlaybackRate();
     if (playback_rate != 1.0f) {
       predicted_play_time = base::TimeDelta::FromMicroseconds(
           static_cast<int64>(ceil(predicted_play_time.InMicroseconds() *
                                   playback_rate)));
     }
     earliest_end_time_ =
         std::max(earliest_end_time_,
                  time_now + request_delay + predicted_play_time);
   }
 }
 
-base::TimeDelta AudioRendererBase::ConvertToDuration(int bytes) {
+base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) {
   if (bytes_per_second_) {
     return base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second_);
   }
   return base::TimeDelta();
 }
 
-void AudioRendererBase::OnRenderError() {
+void AudioRendererImpl::OnRenderError() {
   host()->DisableAudioRenderer();
 }
 
 }  // namespace media