Allow transitioning to HAVE_METADATA before pipeline initialization completes.

media/base/pipeline.cc

 // Copyright (c) 2012 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/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/buffers.h"
 #include "media/base/clock.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
 #include "media/base/video_decoder.h"
+#include "media/base/video_decoder_config.h"
 #include "media/base/video_renderer.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 PipelineStatusNotification::PipelineStatusNotification()
     : cv_(&lock_), status_(PIPELINE_OK), notified_(false) {
 }
 
@@ skipping 66 matching lines @@
   DCHECK(stop_cb_.is_null());
   DCHECK(!seek_pending_);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
 }
 
 void Pipeline::Start(scoped_ptr<FilterCollection> collection,
                      const PipelineStatusCB& ended_cb,
                      const PipelineStatusCB& error_cb,
-                     const PipelineStatusCB& start_cb) {
+                     const PipelineStatusCB& seek_cb,
+                     const BufferingStateCB& buffering_state_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
+  DCHECK(!buffering_state_cb.is_null());
 
   running_ = true;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StartTask, this, base::Passed(&collection),
-      ended_cb, error_cb, start_cb));
+      ended_cb, error_cb, seek_cb, buffering_state_cb));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
   base::AutoLock auto_lock(lock_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StopTask, this, stop_cb));
 }
 
 void Pipeline::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
@@ skipping 145 matching lines @@
 void Pipeline::ReportStatus(const PipelineStatusCB& cb, PipelineStatus status) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (cb.is_null())
     return;
   cb.Run(status);
   // Prevent double-reporting of errors to clients.
   if (status != PIPELINE_OK)
     error_cb_.Reset();
 }
 
-void Pipeline::FinishInitialization() {
+void Pipeline::FinishSeek() {
   DCHECK(message_loop_->BelongsToCurrentThread());
+  seek_timestamp_ = kNoTimestamp();
+  seek_pending_ = false;
+
   // Execute the seek callback, if present.  Note that this might be the
   // initial callback passed into Start().
   ReportStatus(seek_cb_, status_);
-  seek_timestamp_ = kNoTimestamp();
   seek_cb_.Reset();
 }
 
 // static
 bool Pipeline::TransientState(State state) {
   return state == kPausing ||
          state == kFlushing ||
          state == kSeeking ||
          state == kStarting ||
          state == kStopping;
@@ skipping 245 matching lines @@
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
 }
 
 void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
                          const PipelineStatusCB& ended_cb,
                          const PipelineStatusCB& error_cb,
-                         const PipelineStatusCB& start_cb) {
+                         const PipelineStatusCB& seek_cb,
+                         const BufferingStateCB& buffering_state_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
   filter_collection_ = filter_collection.Pass();
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
-  seek_cb_ = start_cb;
+  seek_cb_ = seek_cb;
+  buffering_state_cb_ = buffering_state_cb;
 
   // Kick off initialization.
   pipeline_init_state_.reset(new PipelineInitState());
 
   SetState(kInitDemuxer);
   InitializeDemuxer();
 }
 
 // Main initialization method called on the pipeline thread.  This code attempts
 // to use the specified filter factory to build a pipeline.
@@ skipping 45 matching lines @@
     if (InitializeAudioRenderer(pipeline_init_state_->audio_decoder)) {
       base::AutoLock auto_lock(lock_);
       has_audio_ = true;
       return;
     }
   }
 
   // Assuming audio renderer was created, create video renderer.
   if (state_ == kInitAudioRenderer) {
     SetState(kInitVideoRenderer);
-    if (InitializeVideoRenderer(demuxer_->GetStream(DemuxerStream::VIDEO))) {
+    scoped_refptr<DemuxerStream> video_stream =
+        demuxer_->GetStream(DemuxerStream::VIDEO);
+    if (InitializeVideoRenderer(video_stream)) {
       base::AutoLock auto_lock(lock_);
       has_video_ = true;
+
+      // Get an initial natural size so we have something when we signal
+      // the kHaveMetadata buffering state.
+      natural_size_ = video_stream->video_decoder_config().natural_size();
       return;
     }
   }
 
   if (state_ == kInitVideoRenderer) {
     if (!IsPipelineOk() || !(HasAudio() || HasVideo())) {
       SetError(PIPELINE_ERROR_COULD_NOT_RENDER);
       return;
     }
 
     // Clear initialization state now that we're done.
     filter_collection_.reset();
     pipeline_init_state_.reset();
 
     // Initialization was successful, we are now considered paused, so it's safe
     // to set the initial playback rate and volume.
     PlaybackRateChangedTask(GetPlaybackRate());
     VolumeChangedTask(GetVolume());
 
+    buffering_state_cb_.Run(kHaveMetadata);
+
     // Fire a seek request to get the renderers to preroll. We can skip a seek
     // here as the demuxer should be at the start of the stream.
     seek_pending_ = true;
     SetState(kSeeking);
     seek_timestamp_ = demuxer_->GetStartTime();
     DoSeek(seek_timestamp_, true,
            base::Bind(&Pipeline::OnFilterStateTransition, this));
   }
 }
 
@@ skipping 237 matching lines @@
       DoSeek(seek_timestamp_, false,
              base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else if (state_ == kStarting) {
       DoPlay(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else if (state_ == kStopping) {
       DoStop(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else {
       NOTREACHED() << "Unexpected state: " << state_;
     }
   } else if (state_ == kStarted) {
-    FinishInitialization();
 
-    // Finally, complete the seek.
-    seek_pending_ = false;
+    // Fire canplaythrough immediately after playback begins because of
+    // crbug.com/106480.
+    // TODO(vrk): set ready state to HaveFutureData when bug above is fixed.
+    if (status_ == PIPELINE_OK)
+      buffering_state_cb_.Run(kPrerollCompleted);
+
+    FinishSeek();
 
     // If a playback rate change was requested during a seek, do it now that
     // the seek has compelted.
     if (playback_rate_change_pending_) {
       playback_rate_change_pending_ = false;
       PlaybackRateChangedTask(pending_playback_rate_);
     }
 
     base::AutoLock auto_lock(lock_);
     // We use audio stream to update the clock. So if there is such a stream,
@@ skipping 215 matching lines @@
     case kInitAudioDecoder:
     case kInitAudioRenderer:
     case kInitVideoRenderer:
       // Make it look like initialization was successful.
       filter_collection_.reset();
       pipeline_init_state_.reset();
 
       SetState(kStopping);
       DoStop(base::Bind(&Pipeline::OnTeardownStateTransition, this));
 
-      FinishInitialization();
+      FinishSeek();
       break;
 
     case kPausing:
     case kSeeking:
     case kFlushing:
     case kStarting:
       SetState(kStopping);
       DoStop(base::Bind(&Pipeline::OnTeardownStateTransition, this));
 
-      if (seek_pending_) {
-        seek_pending_ = false;
-        FinishInitialization();
-      }
+      if (seek_pending_)
+        FinishSeek();
 
       break;
 
     case kStarted:
       SetState(kPausing);
       DoPause(base::Bind(&Pipeline::OnTeardownStateTransition, this));
       break;
 
     case kStopping:
     case kStopped:
@@ skipping 46 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media