Reporting a more accurate buffered time for the video tag

Instead of showing that the entire file is buffered when the video first loads, this uses current time, current bytes, and buffered bytes to estimate buffered time.

Reviewed: http://codereview.chromium.org/2085012/
Submitted for: vrk@chromium.org
BUG=42285
TEST=NONE

Review URL: http://codereview.chromium.org/2192001

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@48199 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 29 insertions, 10 deletions

diff --git a/media/base/pipeline_impl.cc b/media/base/pipeline_impl.cc
index b5a193e..532236d 100644
--- a/media/base/pipeline_impl.cc
+++ b/media/base/pipeline_impl.cc
@@ -77,7 +77,8 @@ PipelineImpl::PipelineImpl(MessageLoop* message_loop)
       clock_(&base::Time::Now),
       waiting_for_clock_update_(false),
       state_(kCreated),
-      remaining_transitions_(0) {
+      remaining_transitions_(0),
+      current_bytes_(0) {
   ResetState();
 }
 
@@ -220,24 +221,32 @@ base::TimeDelta PipelineImpl::GetCurrentTime() const {
   return elapsed;
 }
 
-base::TimeDelta PipelineImpl::GetBufferedTime() const {
+
+base::TimeDelta PipelineImpl::GetBufferedTime() {
+  DCHECK(buffered_bytes_ >= current_bytes_);
   AutoLock auto_lock(lock_);
 
   // If buffered time was set, we report that value directly.
   if (buffered_time_.ToInternalValue() > 0)
     return buffered_time_;
 
-  // If buffered time was not set, we use duration and buffered bytes to
-  // estimate the buffered time.
-  // TODO(hclam): The estimation is based on linear interpolation which is
-  // not accurate enough. We should find a better way to estimate the value.
-  if (total_bytes_ == 0)
+  if (total_bytes_ == 0 || current_bytes_ == 0)
     return base::TimeDelta();
 
-  double ratio = static_cast<double>(buffered_bytes_);
-  ratio /= total_bytes_;
+  // If buffered time was not set, we use current time, current bytes, and
+  // buffered bytes to estimate the buffered time.
+  double current_time = static_cast<double>(current_bytes_) / total_bytes_ *
+                        duration_.InMilliseconds();
+  double rate = current_time / current_bytes_;
+  double buffered_time = rate * (buffered_bytes_ - current_bytes_) +
+                         current_time;
+
+  // Only print the max buffered time for smooth buffering.
+  if (buffered_time > max_buffered_time_)
+    max_buffered_time_ = buffered_time;
+
   return base::TimeDelta::FromMilliseconds(
-      static_cast<int64>(duration_.InMilliseconds() * ratio));
+      static_cast<int64>(max_buffered_time_));
 }
 
 base::TimeDelta PipelineImpl::GetMediaDuration() const {
@@ -278,6 +287,16 @@ PipelineError PipelineImpl::GetError() const {
   return error_;
 }
 
+void PipelineImpl::SetCurrentReadPosition(int64 offset) {
+  AutoLock auto_lock(lock_);
+  current_bytes_ = offset;
+}
+
+int64 PipelineImpl::GetCurrentReadPosition() {
+  AutoLock auto_lock(lock_);
+  return current_bytes_;
+}
+
 void PipelineImpl::SetPipelineEndedCallback(PipelineCallback* ended_callback) {
   DCHECK(!IsRunning())
       << "Permanent callbacks should be set before the pipeline has started";