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_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 65 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& start_cb,
+                     const ReadyStateCB& ready_state_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
 
   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, start_cb, ready_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 144 matching lines @@
   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() {
   DCHECK(message_loop_->BelongsToCurrentThread());
+  if (!ready_state_cb_.is_null())
+      ready_state_cb_.Run(HaveEnoughData);

[scherkus (not reviewing), 2012/08/15 19:53:43]

fix indent

[acolwell GONE FROM CHROMIUM, 2012/08/15 23:21:15]

Done.

+
   // 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 ||
@@ skipping 248 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& start_cb,

[Ami GONE FROM CHROMIUM, 2012/08/15 18:00:08]

AFAICT start_cb.Run() is always called with OK (else error_cb.Run() is called),
and start_cb is called exactly when ready_state_cb reports HaveEnoughData.  Is
it time to drop start_cb entirely?

[scherkus (not reviewing), 2012/08/15 19:53:43]

start_cb is set as seek_cb, meaning it will get called w/ the error code and
error_cb is not called

[acolwell GONE FROM CHROMIUM, 2012/08/15 23:21:15]

So I've kept the callback for now, but I've renamed it to seek_cb since it
primarily reflects the success of the initial seek. I've also reorganized the
logic in WebMediaPlayerImpl so that we don't need initialization specific logic.
We just use the existing seek logic. Let me know what you think.

+                         const ReadyStateCB& ready_state_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(kCreated, state_);
   filter_collection_ = filter_collection.Pass();
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = start_cb;
+  ready_state_cb_ = ready_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 HaveMetadata ready 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());
 
+    if (!ready_state_cb_.is_null())
+      ready_state_cb_.Run(HaveMetadata);
+
     // 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 556 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media