Merge 21882 - Implemented a proper clock for audio/video synchronization....

media/base/pipeline_impl.cc

 // Copyright (c) 2008-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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
 #include "base/stl_util-inl.h"
@@ skipping 55 matching lines @@
   CHECK(*count >= 0);
   if (*count == 0) {
     cond_var->Signal();
   }
 }
 
 }  // namespace
 
 PipelineImpl::PipelineImpl(MessageLoop* message_loop)
     : message_loop_(message_loop),
+      clock_(&base::Time::Now),
       state_(kCreated),
       remaining_transitions_(0) {
   ResetState();
 }
 
 PipelineImpl::~PipelineImpl() {
   AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
 }
 
@@ skipping 108 matching lines @@
   volume_ = volume;
   if (running_) {
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &PipelineImpl::VolumeChangedTask,
                           volume));
   }
 }
 
 base::TimeDelta PipelineImpl::GetCurrentTime() const {
   AutoLock auto_lock(lock_);
-  return time_;
+  return clock_.Elapsed();
 }
 
 base::TimeDelta PipelineImpl::GetBufferedTime() const {
   AutoLock auto_lock(lock_);
   return buffered_time_;
 }
 
 base::TimeDelta PipelineImpl::GetDuration() const {
   AutoLock auto_lock(lock_);
   return duration_;
@@ skipping 21 matching lines @@
   AutoLock auto_lock(lock_);
   return error_;
 }
 
 void PipelineImpl::SetPipelineErrorCallback(PipelineCallback* error_callback) {
   error_callback_.reset(error_callback);
 }
 
 void PipelineImpl::ResetState() {
   AutoLock auto_lock(lock_);
+  const base::TimeDelta kZero;
   running_          = false;
-  duration_         = base::TimeDelta();
-  buffered_time_    = base::TimeDelta();
+  duration_         = kZero;
+  buffered_time_    = kZero;
   buffered_bytes_   = 0;
   total_bytes_      = 0;
   video_width_      = 0;
   video_height_     = 0;
   volume_           = 1.0f;
   playback_rate_    = 0.0f;
   error_            = PIPELINE_OK;
-  time_             = base::TimeDelta();
+  clock_.SetTime(kZero);
   rendered_mime_types_.clear();
 }
 
 bool PipelineImpl::IsPipelineOk() {
   return PIPELINE_OK == GetError();
 }
 
 bool PipelineImpl::IsPipelineInitializing() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   return state_ == kInitDataSource ||
@@ skipping 33 matching lines @@
 }
 
 base::TimeDelta PipelineImpl::GetTime() const {
   DCHECK(IsRunning());
   return GetCurrentTime();
 }
 
 void PipelineImpl::SetTime(base::TimeDelta time) {
   DCHECK(IsRunning());
   AutoLock auto_lock(lock_);
-  time_ = time;
+  clock_.SetTime(time);
 }
 
 void PipelineImpl::SetDuration(base::TimeDelta duration) {
   DCHECK(IsRunning());
   AutoLock auto_lock(lock_);
   duration_ = duration;
 }
 
 void PipelineImpl::SetBufferedTime(base::TimeDelta buffered_time) {
   DCHECK(IsRunning());
@@ skipping 219 matching lines @@
 
   // If our owner has requested to be notified of an error, execute
   // |error_callback_| unless we have a "good" error.
   if (error_callback_.get() && error != PIPELINE_STOPPING) {
     error_callback_->Run();
   }
 }
 
 void PipelineImpl::PlaybackRateChangedTask(float playback_rate) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
+  clock_.SetPlaybackRate(playback_rate);
   for (FilterVector::iterator iter = filters_.begin();
        iter != filters_.end();
        ++iter) {
     (*iter)->SetPlaybackRate(playback_rate);
   }
 }
 
 void PipelineImpl::VolumeChangedTask(float volume) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
@@ skipping 24 matching lines @@
   //   kPausing (for each filter)
   //   kSeeking (for each filter)
   //   kStarting (for each filter)
   //   kStarted
   state_ = kPausing;
   seek_timestamp_ = time;
   seek_callback_.reset(seek_callback);
   remaining_transitions_ = filters_.size();
 
   // Kick off seeking!
+  clock_.Pause();
   filters_.front()->Pause(
       NewCallback(this, &PipelineImpl::OnFilterStateTransition));
 }
 
 void PipelineImpl::FilterStateTransitionTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (!StateTransitionsToStarted(state_)) {
     NOTREACHED() << "Invalid current state: " << state_;
     SetError(PIPELINE_ERROR_ABORT);
     return;
   }
 
   // Decrement the number of remaining transitions, making sure to transition
   // to the next state if needed.
   CHECK(remaining_transitions_ <= filters_.size());
   CHECK(remaining_transitions_ > 0u);
   if (--remaining_transitions_ == 0) {
     state_ = FindNextState(state_);
+    if (state_ == kSeeking) {
+      clock_.SetTime(seek_timestamp_);
+    } else if (state_ == kStarting) {
+      clock_.Play();
+    }
+
     if (StateTransitionsToStarted(state_)) {
       remaining_transitions_ = filters_.size();
     }
   }
 
   // Carry out the action for the current state.
   if (StateTransitionsToStarted(state_)) {
     MediaFilter* filter = filters_[filters_.size() - remaining_transitions_];
     if (state_ == kPausing) {
       filter->Pause(NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kSeeking) {
       filter->Seek(seek_timestamp_,
           NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kStarting) {
       filter->Play(NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else {
       NOTREACHED();
     }
   } else if (state_ == kStarted) {
-    // We've completed the seek, update the time.
-    SetTime(seek_timestamp_);
-
     // Execute the seek callback, if present.  Note that this might be the
     // initial callback passed into Start().
     if (seek_callback_.get()) {
       seek_callback_->Run();
       seek_callback_.reset();
     }
 
     // Finally, reset our seeking timestamp back to zero.
     seek_timestamp_ = base::TimeDelta();
   } else {
@@ skipping 157 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