Merge 21611 - Implemented proper pausethenseek behaviour for the media pipeli...

media/filters/audio_renderer_base.cc

 // Copyright (c) 2009 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/base/filter_host.h"
 #include "media/filters/audio_renderer_base.h"
 
 namespace media {
 
 // The maximum size of the queue, which also acts as the number of initial reads
 // to perform for buffering.  The size of the queue should never exceed this
 // number since we read only after we've dequeued and released a buffer in
 // callback thread.
 //
 // This is sort of a magic number, but for 44.1kHz stereo audio this will give
 // us enough data to fill approximately 4 complete callback buffers.
 const size_t AudioRendererBase::kDefaultMaxQueueSize = 16;
 
 AudioRendererBase::AudioRendererBase(size_t max_queue_size)
     : max_queue_size_(max_queue_size),
       data_offset_(0),
-      initialized_(false),
-      stopped_(false) {
+      state_(kUninitialized),
+      pending_reads_(0) {
 }
 
 AudioRendererBase::~AudioRendererBase() {
   // Stop() should have been called and OnReadComplete() should have stopped
   // enqueuing data.
-  DCHECK(stopped_);
+  DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(queue_.empty());
 }
 
+void AudioRendererBase::Play(FilterCallback* callback) {
+  AutoLock auto_lock(lock_);
+  DCHECK_EQ(kPaused, state_);
+  scoped_ptr<FilterCallback> c(callback);
+  state_ = kPlaying;
+  callback->Run();
+}
+
+void AudioRendererBase::Pause(FilterCallback* callback) {
+  AutoLock auto_lock(lock_);
+  DCHECK_EQ(kPlaying, state_);
+  pause_callback_.reset(callback);
+  state_ = kPaused;
+
+  // We'll only pause when we've finished all pending reads.
+  if (pending_reads_ == 0) {
+    pause_callback_->Run();
+    pause_callback_.reset();
+  } else {
+    state_ = kPaused;
+  }
+}
+
 void AudioRendererBase::Stop() {
   OnStop();
 
   AutoLock auto_lock(lock_);
+  state_ = kStopped;
   queue_.clear();
-  stopped_ = true;
 }
 
 void AudioRendererBase::Seek(base::TimeDelta time, FilterCallback* callback) {
   AutoLock auto_lock(lock_);
+  DCHECK_EQ(kPaused, state_);
+  DCHECK_EQ(0u, pending_reads_) << "Pending reads should have completed";
+  state_ = kSeeking;
+  seek_callback_.reset(callback);
+
+  // Throw away everything and schedule our reads.
   last_fill_buffer_time_ = base::TimeDelta();
-
-  // Clear the queue of decoded packets and release the buffers. Fire as many
-  // reads as buffers released. It is safe to schedule reads here because
-  // demuxer and decoders should have received the seek signal.
-  // TODO(hclam): we should preform prerolling again after each seek to avoid
-  // glitch or clicking of audio.
-  while (!queue_.empty()) {
-    queue_.pop_front();
-    ScheduleRead();
+  queue_.clear();
+  data_offset_ = 0;
+  for (size_t i = 0; i < max_queue_size_; ++i) {
+    ScheduleRead_Locked();
   }
 }
 
 void AudioRendererBase::Initialize(AudioDecoder* decoder,
                                    FilterCallback* callback) {
   DCHECK(decoder);
   DCHECK(callback);
+  DCHECK_EQ(kUninitialized, state_);
+  scoped_ptr<FilterCallback> c(callback);
   decoder_ = decoder;
-  initialize_callback_.reset(callback);
 
   // Defer initialization until all scheduled reads have completed.
   if (!OnInitialize(decoder_->media_format())) {
     host()->SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
-    initialize_callback_->Run();
-    initialize_callback_.reset();
+    callback->Run();
+    return;
   }
 
-  // Schedule our initial reads.
-  for (size_t i = 0; i < max_queue_size_; ++i) {
-    ScheduleRead();
+  // Finally, execute the start callback.
+  state_ = kPaused;
+  callback->Run();
+}
+
+void AudioRendererBase::OnReadComplete(Buffer* buffer_in) {
+  AutoLock auto_lock(lock_);
+  DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying);
+  DCHECK_GT(pending_reads_, 0u);
+  --pending_reads_;
+
+  // If we have stopped don't enqueue, same for end of stream buffer since
+  // it has no data.
+  if (!buffer_in->IsEndOfStream()) {
+    queue_.push_back(buffer_in);
+    DCHECK(queue_.size() <= max_queue_size_);
+  }
+
+  // Check for our preroll complete condition.
+  if (state_ == kSeeking) {
+    DCHECK(seek_callback_.get());
+    if (queue_.size() == max_queue_size_ || buffer_in->IsEndOfStream()) {
+      // Transition into paused whether we have data in |queue_| or not.
+      // FillBuffer() will play silence if there's nothing to fill.
+      state_ = kPaused;
+      seek_callback_->Run();
+      seek_callback_.reset();
+    }
+  } else if (state_ == kPaused && pending_reads_ == 0) {
+    // No more pending reads!  We're now officially "paused".
+    if (pause_callback_.get()) {
+      pause_callback_->Run();
+      pause_callback_.reset();
+    }
   }
 }
 
-void AudioRendererBase::OnReadComplete(Buffer* buffer_in) {
-  bool initialization_complete = false;
-  {
-    AutoLock auto_lock(lock_);
-    // If we have stopped don't enqueue, same for end of stream buffer since
-    // it has no data.
-    if (!stopped_ && !buffer_in->IsEndOfStream()) {
-      queue_.push_back(buffer_in);
-      DCHECK(queue_.size() <= max_queue_size_);
-    }
-
-    if (!initialized_) {
-      // We have completed the initialization when we preroll enough and hit
-      // the target queue size or the stream has ended.
-      if (queue_.size() == max_queue_size_ || buffer_in->IsEndOfStream())
-        initialization_complete = true;
-    }
-  }
-
-  if (initialization_complete) {
-    if (queue_.empty()) {
-      // If we say we have initialized but buffer queue is empty, raise an
-      // error.
-      host()->SetError(PIPELINE_ERROR_NO_DATA);
-    } else {
-      initialized_ = true;
-    }
-    initialize_callback_->Run();
-    initialize_callback_.reset();
-  }
-}
-
 // TODO(scherkus): clean up FillBuffer().. it's overly complex!!
 size_t AudioRendererBase::FillBuffer(uint8* dest,
                                      size_t dest_len,
                                      float rate,
                                      const base::TimeDelta& playback_delay) {
-  size_t buffers_released = 0;
   size_t dest_written = 0;
 
   // The timestamp of the last buffer written during the last call to
   // FillBuffer().
   base::TimeDelta last_fill_buffer_time;
   {
     AutoLock auto_lock(lock_);
 
+    // Mute audio by returning 0 when not playing.
+    if (state_ != kPlaying) {
+      return 0;
+    }
+
     // Save a local copy of last fill buffer time and reset the member.
     last_fill_buffer_time = last_fill_buffer_time_;
     last_fill_buffer_time_ = base::TimeDelta();
 
     // Loop until the buffer has been filled.
     while (dest_len > 0 && !queue_.empty()) {
       scoped_refptr<Buffer> buffer = queue_.front();
 
       // Determine how much to copy.
+      DCHECK_LE(data_offset_, buffer->GetDataSize());
       const uint8* data = buffer->GetData() + data_offset_;
       size_t data_len = buffer->GetDataSize() - data_offset_;
 
       // New scaled packet size aligned to 16 to ensure it's on a
       // channel/sample boundary.  Only guaranteed to work for power of 2
       // number of channels and sample size.
       size_t scaled_data_len = (rate <= 0.0f) ? 0 :
           static_cast<size_t>(data_len / rate) & ~15;
       if (scaled_data_len > dest_len) {
         data_len = (data_len * dest_len / scaled_data_len) & ~15;
@@ skipping 34 matching lines @@
       // Check to see if we're finished with the front buffer.
       if (buffer->GetDataSize() - data_offset_ < 16) {
         // Update the time.  If this is the last buffer in the queue, we'll
         // drop out of the loop before len == 0, so we need to always update
         // the time here.
         if (buffer->GetTimestamp().InMicroseconds() > 0) {
           last_fill_buffer_time_ = buffer->GetTimestamp() +
                                    buffer->GetDuration();
         }
 
-        // Dequeue the buffer.
+        // Dequeue the buffer and request another.
         queue_.pop_front();
-        ++buffers_released;
+        ScheduleRead_Locked();
 
         // Reset our offset into the front buffer.
         data_offset_ = 0;
       } else {
         // If we're done with the read, compute the time.
         // Integer divide so multiply before divide to work properly.
         int64 us_written = (buffer->GetDuration().InMicroseconds() *
                             data_offset_) / buffer->GetDataSize();
 
         if (buffer->GetTimestamp().InMicroseconds() > 0) {
           last_fill_buffer_time_ =
               buffer->GetTimestamp() +
               base::TimeDelta::FromMicroseconds(us_written);
         }
       }
     }
-
-    // If we've released any buffers, read more buffers from the decoder.
-    for (size_t i = 0; i < buffers_released; ++i) {
-      ScheduleRead();
-    }
   }
 
   // Update the pipeline's time if it was set last time.
   if (last_fill_buffer_time.InMicroseconds() > 0) {
     // Adjust the |last_fill_buffer_time| with the playback delay.
     // TODO(hclam): If there is a playback delay, the pipeline would not be
     // updated with a correct timestamp when the stream is played at the very
     // end since we use decoded packets to trigger time updates. A better
     // solution is to start a timer when an audio packet is decoded to allow
     // finer time update events.
     if (playback_delay < last_fill_buffer_time)
       last_fill_buffer_time -= playback_delay;
     host()->SetTime(last_fill_buffer_time);
   }
 
   return dest_written;
 }
 
-void AudioRendererBase::ScheduleRead() {
+void AudioRendererBase::ScheduleRead_Locked() {
+  lock_.AssertAcquired();
+  DCHECK_LT(pending_reads_, max_queue_size_);
+  ++pending_reads_;
   decoder_->Read(NewCallback(this, &AudioRendererBase::OnReadComplete));
 }
 
 // static
 bool AudioRendererBase::ParseMediaFormat(const MediaFormat& media_format,
                                          int* channels_out,
                                          int* sample_rate_out,
                                          int* sample_bits_out) {
   // TODO(scherkus): might be handy to support NULL parameters.
   std::string mime_type;
   return media_format.GetAsString(MediaFormat::kMimeType, &mime_type) &&
       media_format.GetAsInteger(MediaFormat::kChannels, channels_out) &&
       media_format.GetAsInteger(MediaFormat::kSampleRate, sample_rate_out) &&
       media_format.GetAsInteger(MediaFormat::kSampleBits, sample_bits_out) &&
       mime_type.compare(mime_type::kUncompressedAudio) == 0;
 }
 
 }  // namespace media