Reporting a more accurate buffered time for the video tag

media/base/pipeline_impl.cc

 // Copyright (c) 2010 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 "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
@@ skipping 59 matching lines @@
   }
 }
 
 }  // namespace
 
 PipelineImpl::PipelineImpl(MessageLoop* message_loop)
     : message_loop_(message_loop),
       clock_(&base::Time::Now),
       waiting_for_clock_update_(false),
       state_(kCreated),
-      remaining_transitions_(0) {
+      remaining_transitions_(0),
+      current_bytes_(0) {
   ResetState();
 }
 
 PipelineImpl::~PipelineImpl() {
   AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
 }
 
 // Creates the PipelineInternal and calls it's start method.
 bool PipelineImpl::Start(FilterFactory* factory,
@@ skipping 122 matching lines @@
   // is set/get under the lock, because this is breaching the contract that
   // |state_| is only accessed on |message_loop_|.
   AutoLock auto_lock(lock_);
   base::TimeDelta elapsed = clock_.Elapsed();
   if (state_ == kEnded || elapsed > duration_) {
     return duration_;
   }
   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 {
   AutoLock auto_lock(lock_);
   return duration_;
 }
 
 int64 PipelineImpl::GetBufferedBytes() const {
   AutoLock auto_lock(lock_);
   return buffered_bytes_;
@@ skipping 20 matching lines @@
 bool PipelineImpl::IsLoaded() const {
   AutoLock auto_lock(lock_);
   return loaded_;
 }
 
 PipelineError PipelineImpl::GetError() const {
   AutoLock auto_lock(lock_);
   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";
   ended_callback_.reset(ended_callback);
 }
 
 void PipelineImpl::SetPipelineErrorCallback(PipelineCallback* error_callback) {
   DCHECK(!IsRunning())
       << "Permanent callbacks should be set before the pipeline has started";
   error_callback_.reset(error_callback);
@@ skipping 699 matching lines @@
 
   // Reset the pipeline, which will decrement a reference to this object.
   // We will get destroyed as soon as the remaining tasks finish executing.
   // To be safe, we'll set our pipeline reference to NULL.
   filters_.clear();
   filter_types_.clear();
   STLDeleteElements(&filter_threads_);
 }
 
 }  // namespace media