Fire canplaythrough event at the proper time for audio/video

media/base/pipeline_impl.cc

 // Copyright (c) 2011 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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "media/base/pipeline_impl.h"
 
 #include <algorithm>
@@ skipping 166 matching lines @@
   base::AutoLock auto_lock(lock_);
   return has_video_;
 }
 
 float PipelineImpl::GetPlaybackRate() const {
   base::AutoLock auto_lock(lock_);
   return playback_rate_;
 }
 
 void PipelineImpl::SetPlaybackRate(float playback_rate) {
-  if (playback_rate < 0.0f) {
+  if (playback_rate < 0.0f)
     return;
-  }
 
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
   if (running_ && !tearing_down_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &PipelineImpl::PlaybackRateChangedTask, this, playback_rate));
   }
 }
 
 float PipelineImpl::GetVolume() const {
   base::AutoLock auto_lock(lock_);
   return volume_;
 }
 
 void PipelineImpl::SetVolume(float volume) {
-  if (volume < 0.0f || volume > 1.0f) {
+  if (volume < 0.0f || volume > 1.0f)
     return;
-  }
 
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_ && !tearing_down_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &PipelineImpl::VolumeChangedTask, this, volume));
   }
 }
 
 Preload PipelineImpl::GetPreload() const {
@@ skipping 12 matching lines @@
 
 base::TimeDelta PipelineImpl::GetCurrentTime() const {
   // TODO(scherkus): perhaps replace checking state_ == kEnded with a bool that
   // is set/get under the lock, because this is breaching the contract that
   // |state_| is only accessed on |message_loop_|.
   base::AutoLock auto_lock(lock_);
   return GetCurrentTime_Locked();
 }
 
 base::TimeDelta PipelineImpl::GetCurrentTime_Locked() const {
+  lock_.AssertAcquired();
   base::TimeDelta elapsed = clock_->Elapsed();
   if (state_ == kEnded || elapsed > duration_) {
     return duration_;
   }
   return elapsed;
 }
 
 base::TimeDelta PipelineImpl::GetBufferedTime() {
   base::AutoLock auto_lock(lock_);
+  return GetBufferedTime_Locked();
+}
 
+base::TimeDelta PipelineImpl::GetBufferedTime_Locked() {
+  lock_.AssertAcquired();
   // If media is fully loaded, then return duration.
   if (loaded_ || total_bytes_ == buffered_bytes_) {
     max_buffered_time_ = duration_;
     return duration_;
   }
 
   base::TimeDelta current_time = GetCurrentTime_Locked();
 
   // If buffered time was set, we report that value directly.
   if (buffered_time_.ToInternalValue() > 0) {
@@ skipping 102 matching lines @@
   volume_           = 1.0f;
   preload_          = AUTO;
   playback_rate_    = 0.0f;
   pending_playback_rate_ = 0.0f;
   status_           = PIPELINE_OK;
   has_audio_        = false;
   has_video_        = false;
   waiting_for_clock_update_ = false;
   audio_disabled_   = false;
   clock_->SetTime(kZero);
+  starting_bytes_loaded_ = 0;
+  starting_time_    = base::Time();
+  has_notified_can_play_through_ = false;
+  is_downloading_data_ = false;
+  last_approximate_download_rate_ = -1;
 }
 
 void PipelineImpl::SetState(State next_state) {
   state_ = next_state;
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
 }
 
 bool PipelineImpl::IsPipelineOk() {
   base::AutoLock auto_lock(lock_);
   return status_ == PIPELINE_OK;
@@ skipping 25 matching lines @@
 }
 
 void PipelineImpl::FinishInitialization() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   // Execute the seek callback, if present.  Note that this might be the
   // initial callback passed into Start().
   if (!seek_callback_.is_null()) {
     seek_callback_.Run(status_);
     seek_callback_.Reset();
   }
+  is_downloading_data_ = true;
+  starting_time_ = base::Time::Now();
+  NotifyCanPlayThroughIfNeeded();
 }
 
 // static
 bool PipelineImpl::TransientState(State state) {
   return state == kPausing ||
          state == kFlushing ||
          state == kSeeking ||
          state == kStarting ||
          state == kStopping;
 }
@@ skipping 80 matching lines @@
   media_log_->AddEvent(
       media_log_->CreateIntegerEvent(
           MediaLogEvent::TOTAL_BYTES_SET, "total_bytes", total_bytes));
 
   base::AutoLock auto_lock(lock_);
   total_bytes_ = total_bytes;
 }
 
 void PipelineImpl::SetBufferedBytes(int64 buffered_bytes) {
   DCHECK(IsRunning());
-  base::AutoLock auto_lock(lock_);
-
-  // See comments in SetCurrentReadPosition() about capping.
-  if (buffered_bytes < current_bytes_)
-    current_bytes_ = buffered_bytes;
-  buffered_bytes_ = buffered_bytes;
+  {
+    base::AutoLock auto_lock(lock_);
+    // See comments in SetCurrentReadPosition() about capping.
+    if (buffered_bytes < current_bytes_)
+      current_bytes_ = buffered_bytes;
+    buffered_bytes_ = buffered_bytes;
+  }
+  NotifyCanPlayThroughIfNeeded();
 }
 
 void PipelineImpl::SetNaturalVideoSize(const gfx::Size& size) {
   DCHECK(IsRunning());
   media_log_->AddEvent(media_log_->CreateVideoSizeSetEvent(
       size.width(), size.height()));
 
   base::AutoLock auto_lock(lock_);
   natural_size_ = size;
 }
 
 void PipelineImpl::SetStreaming(bool streaming) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::STREAMING_SET, "streaming", streaming));
 
   base::AutoLock auto_lock(lock_);
   streaming_ = streaming;
 }
 
 void PipelineImpl::NotifyEnded() {
   DCHECK(IsRunning());
   message_loop_->PostTask(FROM_HERE,
       base::Bind(&PipelineImpl::NotifyEndedTask, this));
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
+  NotifyCanPlayThroughIfNeeded();
 }
 
 void PipelineImpl::SetLoaded(bool loaded) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::LOADED_SET, "loaded", loaded));
 
   base::AutoLock auto_lock(lock_);
   loaded_ = loaded;
 }
 
 void PipelineImpl::SetNetworkActivity(bool is_downloading_data) {
   DCHECK(IsRunning());
+
+  base::AutoLock auto_lock(lock_);

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

Why are we doing these operations here instead of in NotifyNetworkEventTask?

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

Hmm, no real reason; I guess I was doing this here because the
NotifyNetworkEventTask didn't take the "is_downloading_data" param.

Updated NotifyNetworkEventTask accordingly.

+  if (is_downloading_data_ == is_downloading_data)
+    return;
+
+  is_downloading_data_ = is_downloading_data;
+  NetworkEvent type = DOWNLOAD_PAUSED;
+  if (is_downloading_data) {
+    type = DOWNLOAD_CONTINUED;
+    // Reset CanPlayThrough-related state when downloading continues.
+    starting_bytes_loaded_ = buffered_bytes_;
+    starting_time_ = base::Time::Now();
+  }
   message_loop_->PostTask(FROM_HERE,
       base::Bind(
-          &PipelineImpl::NotifyNetworkEventTask, this, is_downloading_data));
+          &PipelineImpl::NotifyNetworkEventTask, this, type));
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading_data));
 }
 
 void PipelineImpl::DisableAudioRenderer() {
   DCHECK(IsRunning());
 
   // Disable renderer on the message loop.
@@ skipping 85 matching lines @@
   // If we have received the stop or error signal, return immediately.
   if (IsPipelineStopPending() || IsPipelineStopped() || !IsPipelineOk())
     return;
 
   DCHECK(state_ == kInitDemuxer ||
          state_ == kInitAudioDecoder ||
          state_ == kInitAudioRenderer ||
          state_ == kInitVideoDecoder ||
          state_ == kInitVideoRenderer);
 
-
   // Demuxer created, create audio decoder.
   if (state_ == kInitDemuxer) {
     SetState(kInitAudioDecoder);
     // If this method returns false, then there's no audio stream.
     if (InitializeAudioDecoder(demuxer_))
       return;
   }
 
   // Assuming audio decoder was created, create audio renderer.
   if (state_ == kInitAudioDecoder) {
@@ skipping 237 matching lines @@
     return;
   }
 
   // Transition to ended, executing the callback if present.
   SetState(kEnded);
   if (!ended_callback_.is_null()) {
     ended_callback_.Run(status_);
   }
 }
 
-void PipelineImpl::NotifyNetworkEventTask(bool is_downloading_data) {
+void PipelineImpl::NotifyNetworkEventTask(NetworkEvent type) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   if (!network_callback_.is_null())
-    network_callback_.Run(is_downloading_data);
+    network_callback_.Run(type);
 }
 
 void PipelineImpl::DisableAudioRendererTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   base::AutoLock auto_lock(lock_);
   has_audio_ = false;
   audio_disabled_ = true;
 
   // Notify all filters of disabled audio renderer. If the filter isn't
@@ skipping 425 matching lines @@
       base::Bind(&PipelineImpl::OnFilterStateTransitionWithStatus, this);
 
   if (status == PIPELINE_OK && pipeline_filter_) {
     pipeline_filter_->Seek(seek_timestamp, done_cb);
     return;
   }
 
   done_cb.Run(status);
 }
 
+void PipelineImpl::NotifyCanPlayThroughIfNeeded() {
+  if (!IsRunning() || !IsInitialized())
+    return;
+
+  base::AutoLock auto_lock(lock_);
+  if (!ShouldNotifyCanPlayThrough_Locked())
+    return;
+
+  has_notified_can_play_through_ = true;
+  message_loop_->PostTask(FROM_HERE,

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

Do we need this PostTask? Aren't we always on the message_loop_ when this is
called? If not, what would we have to do to make it true.

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

I believe we are not on this thread for 2 out of 3 call sites:
SetBufferedBytes() (render thread) and NotifyEnded (audio thread).
Post NotifyCanPlayThrough to message_loop_ at the calling sites?

+      base::Bind(
+         &PipelineImpl::NotifyNetworkEventTask, this, CAN_PLAY_THROUGH));
+}
+
+int PipelineImpl::ApproximateDownloadRate_Locked() {
+  lock_.AssertAcquired();
+
+  // Playback hasn't started yet.
+  if (starting_time_.is_null())
+    return -1;
+
+  float seconds_elapsed = (base::Time::Now() - starting_time_).InSecondsF();
+  DCHECK(seconds_elapsed >= 0);
+  // Update approximation if pipeline is downloading data and has been
+  // downloading data long enough to get an accurate estimate.
+  // XXX: How many seconds should we wait to get an accurate reading?
+  if (is_downloading_data_ && seconds_elapsed > 1) {

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

Make the time elapsed threshold a constant and lets use something like 5 seconds
to start with. Also include a comment above the constant indicating that this
value was pulled out of thin error and will need tuning

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

Done.

+    int bytes_downloaded = buffered_bytes_ - starting_bytes_loaded_;
+    DCHECK(bytes_downloaded > 0);

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

Should this really be a DCHECK? Shouldn't we just put this as part of the
condition above. What if there happens to be some sort of network stall where we
don't get bytes for a little bit? I don't think we want to crash in that case.
We just want to keep the old estimate.

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

Oops, the ">" was meant to be a ">=". Am fine with changing it to an if test
instead.

+    last_approximate_download_rate_ = bytes_downloaded / seconds_elapsed;
+  }
+  return last_approximate_download_rate_;
+}
+
+bool PipelineImpl::ShouldNotifyCanPlayThrough_Locked() {
+  lock_.AssertAcquired();
+  if (has_notified_can_play_through_ || total_bytes_ == 0)

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

Might want to add a comment explaining what total_bytes_ == 0 reflects (ie live
streaming or that we were unable to determine the total size of the stream)

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

Done.

+    return false;
+  if (loaded_ || buffered_bytes_ == total_bytes_)
+    return true;
+
+  int download_rate = ApproximateDownloadRate_Locked();
+  // If download rate is unknown, cannot approximate when the media can play
+  // through.
+  if (download_rate == -1)
+    return false;
+
+  // If we are downloading at or faster than the media's bitrate, then we can
+  // play through to the end of the media without stopping to buffer.
+  int bitrate = demuxer_->GetBitrate();
+  if (download_rate > bitrate * 8)

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

Shouldn't this be (8 * download_rate > bitrate) or (download_rate > bitrate / 8)
?

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

D'OH! Yes, absolutely. Done.

+    return true;
+
+  // If the rate of downloading the media is slower than the rate at which the
+  // media is being played back, see if there's enough data buffered to let the
+  // media play through until the end without buffering.
+  base::TimeDelta current_time = GetCurrentTime_Locked();
+  base::TimeDelta buffered_time = GetBufferedTime_Locked();
+  DCHECK(buffered_time >= current_time);
+  float seconds_buffered = (buffered_time - current_time).InSecondsF();

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

std::max(..., 0) to protect the computation in release builds.

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

Done.

+  int bytes_downloaded_after_buffer_is_consumed =

[acolwell GONE FROM CHROMIUM, 2011/10/28 18:24:13]

s/after/while/ ?

[vrk (LEFT CHROMIUM), 2011/11/01 21:57:34]

Done.

+      static_cast<int>(seconds_buffered * download_rate);
+  int bytes_left_to_download = total_bytes_ - buffered_bytes_;
+
+  return bytes_downloaded_after_buffer_is_consumed >= bytes_left_to_download;
+}
+
 }  // namespace media