Revert of Update AudioRenderer API to fire changes in BufferingState.

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),
-      buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(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);
@@ skipping 12 matching lines @@
     DCHECK(!sink_playing_);
     return;
   }
 
   StartRendering_Locked();
 }
 
 void AudioRendererImpl::StartRendering_Locked() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK_EQ(state_, kPlaying);
+  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();
   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;
   }
 
   StopRendering_Locked();
 }
 
 void AudioRendererImpl::StopRendering_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK_EQ(state_, kPlaying);
+  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) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
-  DCHECK_EQ(state_, kPlaying);
+  DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow)
+      << "state_=" << state_;
   DCHECK(flush_cb_.is_null());
 
   flush_cb_ = callback;
-  ChangeState_Locked(kFlushing);
 
-  if (pending_read_)
+  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);
 
   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(!flush_cb_.is_null());
 
     audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
-
-    // Flush() may have been called while underflowed/not fully buffered.
-    if (buffering_state_ != BUFFERING_HAVE_NOTHING)
-      SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
+    preroll_aborted_ = false;
 
     earliest_end_time_ = now_cb_.Run();
     splicer_->Reset();
     if (buffer_converter_)
       buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void AudioRendererImpl::Stop(const base::Closure& callback) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!callback.is_null());
 
   // TODO(scherkus): Consider invalidating |weak_factory_| and replacing
   // task-running guards that check |state_| with DCHECK().
 
   {
     base::AutoLock auto_lock(lock_);
 
     if (state_ == kStopped) {
       task_runner_->PostTask(FROM_HERE, callback);
       return;
     }
 
     ChangeState_Locked(kStopped);
     algorithm_.reset();
+    underflow_cb_.Reset();
     time_cb_.Reset();
     flush_cb_.Reset();
   }
 
   if (sink_) {
     sink_->Stop();
     sink_ = NULL;
   }
 
   audio_buffer_stream_.Stop(callback);
 }
 
-void AudioRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
-  DVLOG(1) << __FUNCTION__ << "(" << timestamp.InMicroseconds() << ")";
+void AudioRendererImpl::Preroll(base::TimeDelta time,
+                                const PipelineStatusCB& cb) {
+  DVLOG(1) << __FUNCTION__ << "(" << time.InMicroseconds() << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!sink_playing_);
   DCHECK_EQ(state_, kFlushed);
-  DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
+  DCHECK(preroll_cb_.is_null());
 
-  ChangeState_Locked(kPlaying);
-  start_timestamp_ = timestamp;
+  ChangeState_Locked(kPrerolling);
+  preroll_cb_ = cb;
+  preroll_timestamp_ = time;
 
   AttemptRead_Locked();
 }
 
 void AudioRendererImpl::Initialize(DemuxerStream* stream,
                                    const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
+                                   const base::Closure& underflow_cb,
                                    const TimeCB& time_cb,
-                                   const BufferingStateCB& buffering_state_cb,
                                    const base::Closure& ended_cb,
                                    const PipelineStatusCB& error_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
+  DCHECK(!underflow_cb.is_null());
   DCHECK(!time_cb.is_null());
-  DCHECK(!buffering_state_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(sink_);
 
   state_ = kInitializing;
 
   init_cb_ = init_cb;
+  underflow_cb_ = underflow_cb;
   time_cb_ = time_cb;
-  // Callback can be run from audio callback thread in Render().
-  buffering_state_cb_ = BindToCurrentLoop(buffering_state_cb);
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
 
   expecting_config_changes_ = stream->SupportsConfigChanges();
   if (!expecting_config_changes_) {
     // The actual buffer size is controlled via the size of the AudioBus
     // provided to Render(), so just choose something reasonable here for looks.
     int buffer_size = stream->audio_decoder_config().samples_per_second() / 100;
     audio_parameters_.Reset(
         AudioParameters::AUDIO_PCM_LOW_LATENCY,
@@ skipping 69 matching lines @@
 
     // Some sinks play on start...
     sink_->Pause();
   }
 
   DCHECK(!sink_playing_);
 
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
+void AudioRendererImpl::ResumeAfterUnderflow() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  base::AutoLock auto_lock(lock_);
+  if (state_ == kUnderflow) {
+    // The "!preroll_aborted_" is a hack. If preroll is aborted, then we
+    // shouldn't even reach the kUnderflow state to begin with. But for now
+    // we're just making sure that the audio buffer capacity (i.e. the
+    // number of bytes that need to be buffered for preroll to complete)
+    // does not increase due to an aborted preroll.
+    // TODO(vrk): Fix this bug correctly! (crbug.com/151352)
+    if (!preroll_aborted_)
+      algorithm_->IncreaseQueueCapacity();
+
+    ChangeState_Locked(kRebuffering);
+  }
+}
+
 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 << ")";
@@ skipping 41 matching lines @@
     }
   }
 
   if (!splicer_->HasNextBuffer()) {
     AttemptRead_Locked();
     return;
   }
 
   bool need_another_buffer = false;
   while (splicer_->HasNextBuffer())
-    need_another_buffer = HandleSplicerBuffer_Locked(splicer_->GetNextBuffer());
+    need_another_buffer = HandleSplicerBuffer(splicer_->GetNextBuffer());
 
   if (!need_another_buffer && !CanRead_Locked())
     return;
 
   AttemptRead_Locked();
 }
 
-bool AudioRendererImpl::HandleSplicerBuffer_Locked(
+bool AudioRendererImpl::HandleSplicerBuffer(
     const scoped_refptr<AudioBuffer>& buffer) {
-  lock_.AssertAcquired();
   if (buffer->end_of_stream()) {
     received_end_of_stream_ = true;
+
+    // Transition to kPlaying if we are currently handling an underflow since
+    // no more data will be arriving.
+    if (state_ == kUnderflow || state_ == kRebuffering)
+      ChangeState_Locked(kPlaying);
   } else {
-    if (state_ == kPlaying) {
-      if (IsBeforeStartTime(buffer))
+    if (state_ == kPrerolling) {
+      if (IsBeforePrerollTime(buffer))
         return true;
 
-      // Trim off any additional time before the start timestamp.
-      const base::TimeDelta trim_time = start_timestamp_ - buffer->timestamp();
+      // Trim off any additional time before the preroll timestamp.
+      const base::TimeDelta trim_time =
+          preroll_timestamp_ - buffer->timestamp();
       if (trim_time > base::TimeDelta()) {
         buffer->TrimStart(buffer->frame_count() *
                           (static_cast<double>(trim_time.InMicroseconds()) /
                            buffer->duration().InMicroseconds()));
       }
       // If the entire buffer was trimmed, request a new one.
       if (!buffer->frame_count())
         return true;
     }
 
     if (state_ != kUninitialized && state_ != kStopped)
       algorithm_->EnqueueBuffer(buffer);
   }
 
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
       NOTREACHED();
       return false;
 
     case kFlushed:
       DCHECK(!pending_read_);
       return false;
 
+    case kPrerolling:
+      if (!buffer->end_of_stream() && !algorithm_->IsQueueFull())
+        return true;
+      ChangeState_Locked(kPlaying);
+      base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
+      return false;
+
     case kPlaying:
-      if (buffer->end_of_stream() || algorithm_->IsQueueFull()) {
-        if (buffering_state_ == BUFFERING_HAVE_NOTHING)
-          SetBufferingState_Locked(BUFFERING_HAVE_ENOUGH);
-        return false;
-      }
-      return true;
+    case kUnderflow:
+      return false;
+
+    case kRebuffering:
+      if (!algorithm_->IsQueueFull())
+        return true;
+      ChangeState_Locked(kPlaying);
+      return false;
 
     case kStopped:
       return false;
   }
   return false;
 }
 
 void AudioRendererImpl::AttemptRead() {
   base::AutoLock auto_lock(lock_);
   AttemptRead_Locked();
@@ skipping 10 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 kFlushing:
-    case kFlushed:
     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());
@@ skipping 15 matching lines @@
     StartRendering_Locked();
     return;
   }
 
   if (current_playback_rate != 0 && playback_rate == 0) {
     StopRendering_Locked();
     return;
   }
 }
 
-bool AudioRendererImpl::IsBeforeStartTime(
+bool AudioRendererImpl::IsBeforePrerollTime(
     const scoped_refptr<AudioBuffer>& buffer) {
-  DCHECK_EQ(state_, kPlaying);
+  DCHECK_EQ(state_, kPrerolling);
   return buffer && !buffer->end_of_stream() &&
-         (buffer->timestamp() + buffer->duration()) < start_timestamp_;
+         (buffer->timestamp() + buffer->duration()) < preroll_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               int audio_delay_milliseconds) {
   const int requested_frames = audio_bus->frames();
   base::TimeDelta playback_delay = base::TimeDelta::FromMilliseconds(
       audio_delay_milliseconds);
   const int delay_frames = static_cast<int>(playback_delay.InSecondsF() *
                                             audio_parameters_.sample_rate());
   int frames_written = 0;
   base::Closure time_cb;
+  base::Closure underflow_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();
@@ skipping 33 matching lines @@
     audio_clock_->WroteSilence(requested_frames - frames_written, delay_frames);
 
     if (frames_written == 0) {
       const base::TimeTicks now = now_cb_.Run();
 
       if (received_end_of_stream_ && !rendered_end_of_stream_ &&
           now >= earliest_end_time_) {
         rendered_end_of_stream_ = true;
         ended_cb_.Run();
       } else if (!received_end_of_stream_ && state_ == kPlaying) {
-        if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
-          algorithm_->IncreaseQueueCapacity();
-          SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
-        }
+        ChangeState_Locked(kUnderflow);
+        underflow_cb = underflow_cb_;
       } else {
         // We can't write any data this cycle. For example, we may have
         // sent all available data to the audio device while not reaching
         // |earliest_end_time_|.
       }
     }
 
     if (CanRead_Locked()) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&AudioRendererImpl::AttemptRead,
@@ skipping 12 matching lines @@
 
     if (frames_written > 0) {
       UpdateEarliestEndTime_Locked(
           frames_written, playback_delay, now_cb_.Run());
     }
   }
 
   if (!time_cb.is_null())
     time_cb.Run();
 
+  if (!underflow_cb.is_null())
+    underflow_cb.Run();
+
   DCHECK_LE(frames_written, requested_frames);
   return frames_written;
 }
 
 void AudioRendererImpl::UpdateEarliestEndTime_Locked(
     int frames_filled, const base::TimeDelta& playback_delay,
     const base::TimeTicks& time_now) {
   DCHECK_GT(frames_filled, 0);
 
   base::TimeDelta predicted_play_time = base::TimeDelta::FromMicroseconds(
@@ skipping 18 matching lines @@
   lock_.AssertAcquired();
 
   PipelineStatus status = is_decode_error ? PIPELINE_ERROR_DECODE : PIPELINE_OK;
   switch (state_) {
     case kUninitialized:
     case kInitializing:
       NOTREACHED();
       return;
     case kFlushing:
       ChangeState_Locked(kFlushed);
+
       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);
+      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;
   }
 }
 
 void AudioRendererImpl::ChangeState_Locked(State new_state) {
   DVLOG(1) << __FUNCTION__ << " : " << state_ << " -> " << new_state;
   lock_.AssertAcquired();
   state_ = new_state;
 }
 
 void AudioRendererImpl::OnNewSpliceBuffer(base::TimeDelta splice_timestamp) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   splicer_->SetSpliceTimestamp(splice_timestamp);
 }
 
 void AudioRendererImpl::OnConfigChange() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   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()));
 }
 
-void AudioRendererImpl::SetBufferingState_Locked(
-    BufferingState buffering_state) {
-  DVLOG(1) << __FUNCTION__ << " : " << buffering_state_ << " -> "
-           << buffering_state;
-  DCHECK_NE(buffering_state_, buffering_state);
-  lock_.AssertAcquired();
-  buffering_state_ = buffering_state;
-  buffering_state_cb_.Run(buffering_state_);
-}
-
 }  // namespace media