Let audio wait for video to finish prerolling after seek

media/base/android/media_source_player.cc

 // Copyright (c) 2013 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/android/media_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 26 matching lines @@
       pending_event_(NO_EVENT_PENDING),
       playing_(false),
       interpolator_(&default_tick_clock_),
       doing_browser_seek_(false),
       pending_seek_(false),
       drm_bridge_(NULL),
       cdm_registration_id_(0),
       is_waiting_for_key_(false),
       is_waiting_for_audio_decoder_(false),
       is_waiting_for_video_decoder_(false),
+      prerolling_(false),
       weak_factory_(this) {
   audio_decoder_job_.reset(new AudioDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::AUDIO),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
                  weak_factory_.GetWeakPtr())));
   video_decoder_job_.reset(new VideoDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
@@ skipping 282 matching lines @@
   base::TimeDelta current_time = GetCurrentTime();
   // TODO(qinmin): Simplify the logic by using |start_presentation_timestamp_|
   // to preroll media decoder jobs. Currently |start_presentation_timestamp_|
   // is calculated from decoder output, while preroll relies on the access
   // unit's timestamp. There are some differences between the two.
   preroll_timestamp_ = current_time;
   if (HasAudio())
     audio_decoder_job_->BeginPrerolling(preroll_timestamp_);
   if (HasVideo())
     video_decoder_job_->BeginPrerolling(preroll_timestamp_);
+  prerolling_ = true;
 
   if (!doing_browser_seek_)
     manager()->OnSeekComplete(player_id(), current_time);
 
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::UpdateTimestamps(
     base::TimeDelta current_presentation_timestamp,
     base::TimeDelta max_presentation_timestamp) {
@@ skipping 143 matching lines @@
     is_waiting_for_key_ = true;
     return;
   }
 
   // If the status is MEDIA_CODEC_STOPPED, stop decoding new data. The player is
   // in the middle of a seek or stop event and needs to wait for the IPCs to
   // come.
   if (status == MEDIA_CODEC_STOPPED)
     return;
 
+  if (prerolling_ && IsPrerollFinished(is_audio)) {
+    if (IsPrerollFinished(!is_audio)) {
+      prerolling_ = false;
+      StartInternal();
+    }
+    return;
+  }
+
   if (is_clock_manager) {
     // If we have a valid timestamp, start the starvation callback. Otherwise,
     // reset the |start_time_ticks_| so that the next frame will not suffer
     // from the decoding delay caused by the current frame.
     if (current_presentation_timestamp != kNoTimestamp())
       StartStarvationCallback(current_presentation_timestamp,
                               max_presentation_timestamp);
     else
       start_time_ticks_ = base::TimeTicks::Now();
   }
 
   if (is_audio)
     DecodeMoreAudio();
   else
     DecodeMoreVideo();
 }
 
+bool MediaSourcePlayer::IsPrerollFinished(bool is_audio) const {
+  if (is_audio)
+    return !HasAudio() || !audio_decoder_job_->prerolling();
+  return !HasVideo() || !video_decoder_job_->prerolling();
+}
+
 void MediaSourcePlayer::DecodeMoreAudio() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!audio_decoder_job_->is_decoding());
   DCHECK(!AudioFinished());
 
   if (audio_decoder_job_->Decode(
       start_time_ticks_,
       start_presentation_timestamp_,
       base::Bind(&MediaSourcePlayer::MediaDecoderCallback, weak_this_, true))) {
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreAudio",
@@ skipping 43 matching lines @@
   }
 }
 
 void MediaSourcePlayer::ClearDecodingData() {
   DVLOG(1) << __FUNCTION__;
   audio_decoder_job_->Flush();
   video_decoder_job_->Flush();
   start_time_ticks_ = base::TimeTicks();
 }
 
-bool MediaSourcePlayer::HasVideo() {
+bool MediaSourcePlayer::HasVideo() const {
   return video_decoder_job_->HasStream();
 }
 
-bool MediaSourcePlayer::HasAudio() {
+bool MediaSourcePlayer::HasAudio() const {
   return audio_decoder_job_->HasStream();
 }
 
 bool MediaSourcePlayer::AudioFinished() {
   return audio_decoder_job_->OutputEOSReached() || !HasAudio();
 }
 
 bool MediaSourcePlayer::VideoFinished() {
   return video_decoder_job_->OutputEOSReached() || !HasVideo();
 }
@@ skipping 148 matching lines @@
   // support setMediaKeys(0) (see http://crbug.com/330324), or when we release
   // MediaDrm when the video is paused, or when the device goes to sleep (see
   // http://crbug.com/272421).
   audio_decoder_job_->SetDrmBridge(NULL);
   video_decoder_job_->SetDrmBridge(NULL);
   cdm_registration_id_ = 0;
   drm_bridge_ = NULL;
 }
 
 }  // namespace media