Revert of Rename AudioRenderer::Play/Pause() to Start/StopRendering().

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 36 matching lines @@
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     AudioHardwareConfig* hardware_config)
     : task_runner_(task_runner),
       sink_(sink),
       audio_buffer_stream_(task_runner,
                            decoders.Pass(),
                            set_decryptor_ready_cb),
       hardware_config_(hardware_config),
       now_cb_(base::Bind(&base::TimeTicks::Now)),
       state_(kUninitialized),
-      rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       underflow_disabled_(false),
       preroll_aborted_(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__;
+void AudioRendererImpl::Play() {
   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) {
+  DCHECK_EQ(state_, kPaused);
+  ChangeState_Locked(kPlaying);
+  earliest_end_time_ = now_cb_.Run();
+
+  if (algorithm_->playback_rate() != 0)
+    DoPlay_Locked();
+  else
     DCHECK(!sink_playing_);
-    return;
-  }
-
-  StartRendering_Locked();
 }
 
-void AudioRendererImpl::StartRendering_Locked() {
-  DVLOG(1) << __FUNCTION__;
+void AudioRendererImpl::DoPlay_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow)
-      << "state_=" << state_;
-  DCHECK(!sink_playing_);
-  DCHECK_NE(algorithm_->playback_rate(), 0);
+  lock_.AssertAcquired();
+  earliest_end_time_ = now_cb_.Run();
+
+  if ((state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow) &&
+      !sink_playing_) {
+    {
+      base::AutoUnlock auto_unlock(lock_);
+      sink_->Play();
+    }
+
+    sink_playing_ = true;
+  }
+}
+
+void AudioRendererImpl::Pause() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  base::AutoLock auto_lock(lock_);
+  DCHECK(state_ == kPlaying || state_ == kUnderflow ||
+         state_ == kRebuffering) << "state_ == " << state_;
+  ChangeState_Locked(kPaused);
+
+  DoPause_Locked();
+}
+
+void AudioRendererImpl::DoPause_Locked() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
-  earliest_end_time_ = now_cb_.Run();
-  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) {
-    DCHECK(!sink_playing_);
-    return;
+  if (sink_playing_) {
+    {
+      base::AutoUnlock auto_unlock(lock_);
+      sink_->Pause();
+    }
+    sink_playing_ = false;
   }
-
-  StopRendering_Locked();
-}
-
-void AudioRendererImpl::StopRendering_Locked() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow)
-      << "state_=" << state_;
-  DCHECK(sink_playing_);
-  lock_.AssertAcquired();
-
-  sink_playing_ = false;
-
-  base::AutoUnlock auto_unlock(lock_);
-  sink_->Pause();
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
-  DCHECK_EQ(state_, kPlaying);
+  DCHECK_EQ(state_, kPaused);
   DCHECK(flush_cb_.is_null());
 
   flush_cb_ = callback;
 
   if (pending_read_) {
     ChangeState_Locked(kFlushing);
     return;
   }
 
-  ChangeState_Locked(kFlushed);
   DoFlush_Locked();
 }
 
 void AudioRendererImpl::DoFlush_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   DCHECK(!pending_read_);
-  DCHECK_EQ(state_, kFlushed);
+  DCHECK_EQ(state_, kPaused);
 
   audio_buffer_stream_.Reset(base::Bind(&AudioRendererImpl::ResetDecoderDone,
                                         weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::ResetDecoderDone() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock auto_lock(lock_);
     if (state_ == kStopped)
       return;
 
-    DCHECK_EQ(state_, kFlushed);
+    DCHECK_EQ(state_, kPaused);
     DCHECK(!flush_cb_.is_null());
 
     audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
     preroll_aborted_ = false;
 
     earliest_end_time_ = now_cb_.Run();
     splicer_->Reset();
     if (buffer_converter_)
@@ skipping 32 matching lines @@
 
   audio_buffer_stream_.Stop(callback);
 }
 
 void AudioRendererImpl::Preroll(base::TimeDelta time,
                                 const PipelineStatusCB& cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!sink_playing_);
-  DCHECK_EQ(state_, kFlushed);
+  DCHECK_EQ(state_, kPaused);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
   DCHECK(preroll_cb_.is_null());
 
   ChangeState_Locked(kPrerolling);
   preroll_cb_ = cb;
   preroll_timestamp_ = time;
 
   AttemptRead_Locked();
 }
 
@@ skipping 85 matching lines @@
 
   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_);
 
-  ChangeState_Locked(kFlushed);
+  ChangeState_Locked(kPaused);
 
   HistogramRendererEvent(INITIALIZED);
 
   {
     base::AutoUnlock auto_unlock(lock_);
     sink_->Initialize(audio_parameters_, this);
     sink_->Start();
 
     // Some sinks play on start...
     sink_->Pause();
@@ skipping 23 matching lines @@
 
 void AudioRendererImpl::SetVolume(float volume) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(sink_);
   sink_->SetVolume(volume);
 }
 
 void AudioRendererImpl::DecodedAudioReady(
     AudioBufferStream::Status status,
     const scoped_refptr<AudioBuffer>& buffer) {
-  DVLOG(2) << __FUNCTION__ << "(" << status << ")";
+  DVLOG(1) << __FUNCTION__ << "(" << status << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
   if (status == AudioBufferStream::ABORTED ||
       status == AudioBufferStream::DEMUXER_READ_ABORTED) {
     HandleAbortedReadOrDecodeError(false);
     return;
   }
 
   if (status == AudioBufferStream::DECODE_ERROR) {
     HandleAbortedReadOrDecodeError(true);
     return;
   }
 
   DCHECK_EQ(status, AudioBufferStream::OK);
   DCHECK(buffer.get());
 
   if (state_ == kFlushing) {
-    ChangeState_Locked(kFlushed);
+    ChangeState_Locked(kPaused);
     DoFlush_Locked();
     return;
   }
 
   if (expecting_config_changes_) {
     DCHECK(buffer_converter_);
     buffer_converter_->AddInput(buffer);
     while (buffer_converter_->HasNextBuffer()) {
       if (!splicer_->AddInput(buffer_converter_->GetNextBuffer())) {
         HandleAbortedReadOrDecodeError(true);
@@ skipping 53 matching lines @@
       algorithm_->EnqueueBuffer(buffer);
   }
 
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
       NOTREACHED();
       return false;
 
-    case kFlushed:
+    case kPaused:
       DCHECK(!pending_read_);
       return false;
 
     case kPrerolling:
       if (!buffer->end_of_stream() && !algorithm_->IsQueueFull())
         return true;
-      ChangeState_Locked(kPlaying);
+      ChangeState_Locked(kPaused);
       base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
       return false;
 
     case kPlaying:
     case kUnderflow:
       return false;
 
     case kRebuffering:
       if (!algorithm_->IsQueueFull())
         return true;
@@ skipping 22 matching lines @@
   audio_buffer_stream_.Read(base::Bind(&AudioRendererImpl::DecodedAudioReady,
                                        weak_factory_.GetWeakPtr()));
 }
 
 bool AudioRendererImpl::CanRead_Locked() {
   lock_.AssertAcquired();
 
   switch (state_) {
     case kUninitialized:
     case kInitializing:
-    case kFlushed:
+    case kPaused:
     case kFlushing:
     case kStopped:
       return false;
 
     case kPrerolling:
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
       break;
   }
 
   return !pending_read_ && !received_end_of_stream_ &&
       !algorithm_->IsQueueFull();
 }
 
 void AudioRendererImpl::SetPlaybackRate(float playback_rate) {
   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();
+  if (current_playback_rate == 0 && playback_rate != 0)
+    DoPlay_Locked();
+  else if (current_playback_rate != 0 && playback_rate == 0)
+    DoPause_Locked();
+
   algorithm_->SetPlaybackRate(playback_rate);
-
-  if (!rendering_)
-    return;
-
-  if (current_playback_rate == 0 && playback_rate != 0) {
-    StartRendering_Locked();
-    return;
-  }
-
-  if (current_playback_rate != 0 && playback_rate == 0) {
-    StopRendering_Locked();
-    return;
-  }
 }
 
 bool AudioRendererImpl::IsBeforePrerollTime(
     const scoped_refptr<AudioBuffer>& buffer) {
   DCHECK_EQ(state_, kPrerolling);
   return buffer && !buffer->end_of_stream() &&
          (buffer->timestamp() + buffer->duration()) < preroll_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
@@ skipping 130 matching lines @@
 
 void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {
   lock_.AssertAcquired();
 
   PipelineStatus status = is_decode_error ? PIPELINE_ERROR_DECODE : PIPELINE_OK;
   switch (state_) {
     case kUninitialized:
     case kInitializing:
       NOTREACHED();
       return;
+    case kPaused:
+      if (status != PIPELINE_OK)
+        error_cb_.Run(status);
+      return;
     case kFlushing:
-      ChangeState_Locked(kFlushed);
+      ChangeState_Locked(kPaused);
 
       if (status == PIPELINE_OK) {
         DoFlush_Locked();
         return;
       }
 
       error_cb_.Run(status);
       base::ResetAndReturn(&flush_cb_).Run();
       return;
     case kPrerolling:
       // This is a signal for abort if it's not an error.
       preroll_aborted_ = !is_decode_error;
-      ChangeState_Locked(kPlaying);
+      ChangeState_Locked(kPaused);
       base::ResetAndReturn(&preroll_cb_).Run(status);
       return;
-    case kFlushed:
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
@@ skipping 13 matching lines @@
   DCHECK(expecting_config_changes_);
   buffer_converter_->ResetTimestampState();
   // Drain flushed buffers from the converter so the AudioSplicer receives all
   // data ahead of any OnNewSpliceBuffer() calls.  Since discontinuities should
   // only appear after config changes, AddInput() should never fail here.
   while (buffer_converter_->HasNextBuffer())
     CHECK(splicer_->AddInput(buffer_converter_->GetNextBuffer()));
 }
 
 }  // namespace media