MediaCodecPlayer implementation (stage 4 - preroll)

media/base/android/media_codec_player.cc

 // Copyright 2015 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_codec_player.h"
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 414 matching lines @@
 
   // Restrict the current time to be equal to seek_time
   // for the next StartPlaybackDecoders() call.
 
   base::TimeDelta seek_time = seek_info_->is_browser_seek
                                   ? actual_browser_seek_time
                                   : seek_info_->seek_time;
 
   interpolator_.SetBounds(seek_time, seek_time);
   audio_decoder_->SetBaseTimestamp(seek_time);
+  audio_decoder_->SetNeedsPreroll(true);
+  video_decoder_->SetNeedsPreroll(true);
 
   // The Flush() might set the state to kStateError.
   if (state_ == kStateError) {
     // Notify the Renderer.
     if (!seek_info_->is_browser_seek)
       ui_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(seek_done_cb_, seek_time));
 
     seek_info_.reset();
     return;
@@ skipping 30 matching lines @@
 }
 
 void MediaCodecPlayer::OnDemuxerDurationChanged(
     base::TimeDelta duration) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " duration:" << duration;
 
   duration_ = duration;
 }
 
+void MediaCodecPlayer::SetDecodersTimeCallbackForTests(
+    DecodersTimeCallback cb) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  decoders_time_cb_ = cb;
+}
+
+bool MediaCodecPlayer::IsPrerollingForTests(DemuxerStream::Type type) const {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(audio_decoder_ && video_decoder_);
+
+  if (type == DemuxerStream::AUDIO)
+    return audio_decoder_->IsPrerollingForTests();
+  else if (type == DemuxerStream::VIDEO)
+    return video_decoder_->IsPrerollingForTests();
+  else
+    return false;
+}
+
 // Events from Player, called on UI thread
 
 void MediaCodecPlayer::OnMediaMetadataChanged(base::TimeDelta duration,
                                               const gfx::Size& video_size) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
   if (duration != kNoTimestamp())
     metadata_cache_.duration = duration;
 
   if (!video_size.IsEmpty())
@@ skipping 53 matching lines @@
 
   if (HasVideo() && !video_decoder_->HasVideoSurface()) {
     SetState(kStateWaitingForSurface);
     return;
   }
 
   SetState(kStatePlaying);
   StartPlaybackOrBrowserSeek();
 }
 
+void MediaCodecPlayer::OnPrerollDone() {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  if (!(audio_decoder_->IsPrerollDone() && video_decoder_->IsPrerollDone())) {
+    DVLOG(1) << __FUNCTION__ << " both audio and video needs to be done"
+             << " prerolling, ignoring";
+    return;  // Wait until both streams are done prerolling.
+  }
+
+  if (!AudioFinished())
+    audio_decoder_->ResumeAfterPreroll();
+  if (!VideoFinished())
+    video_decoder_->ResumeAfterPreroll();
+}
+
 void MediaCodecPlayer::OnStopDone() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
-  if (!(audio_decoder_->IsStopped() && video_decoder_->IsStopped()))
+  if (!(audio_decoder_->IsStopped() && video_decoder_->IsStopped())) {
+    DVLOG(1) << __FUNCTION__ << " both audio and video has to be stopped"
+             << ", ignoring";
     return;  // Wait until other stream is stopped
+  }
 
   // At this point decoder threads should not be running
   if (interpolator_.interpolating())
     interpolator_.StopInterpolating();
 
   base::TimeDelta seek_time;
   switch (state_) {
     case kStateStopping: {
       base::TimeDelta seek_time = GetPendingSeek();
       if (seek_time != kNoTimestamp()) {
@@ skipping 55 matching lines @@
 }
 
 void MediaCodecPlayer::OnTimeIntervalUpdate(DemuxerStream::Type type,
                                             base::TimeDelta now_playing,
                                             base::TimeDelta last_buffered) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   DVLOG(2) << __FUNCTION__ << ": stream type:" << type << " [" << now_playing
            << "," << last_buffered << "]";
 
+  // For testing only: report time interval as we receive it from decoders
+  // as an indication of what is being rendered.
+  if (!decoders_time_cb_.is_null()) {
+    ui_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(decoders_time_cb_, type, now_playing, last_buffered));
+  }
+
   // I assume that audio stream cannot be added after we get configs by
   // OnDemuxerConfigsAvailable(), but that audio can finish early.
 
   if (type == DemuxerStream::VIDEO) {
     // Ignore video PTS if there is audio stream or if it's behind current
     // time as set by audio stream.
-    if (!AudioFinished() || now_playing < interpolator_.GetInterpolatedTime())
+    if (!AudioFinished() ||
+        (HasAudio() && now_playing < interpolator_.GetInterpolatedTime()))
       return;
   }
 
   interpolator_.SetBounds(now_playing, last_buffered);
 
   // Post to UI thread
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(time_update_cb_, GetInterpolatedTime(),
                                        base::TimeTicks::Now()));
 }
@@ skipping 259 matching lines @@
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   internal_error_cb_ = base::Bind(&MediaCodecPlayer::OnError, media_weak_this_);
 
   audio_decoder_.reset(new MediaCodecAudioDecoder(
       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
                                        media_weak_this_, DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::AUDIO),
+      base::Bind(&MediaCodecPlayer::OnPrerollDone, media_weak_this_),
       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_),
       internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
                  DemuxerStream::AUDIO)));
 
   video_decoder_.reset(new MediaCodecVideoDecoder(
       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
                                        media_weak_this_, DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::VIDEO),
+      base::Bind(&MediaCodecPlayer::OnPrerollDone, media_weak_this_),
       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_),
       internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnVideoResolutionChanged, media_weak_this_),
       base::Bind(&MediaCodecPlayer::OnVideoCodecCreated, media_weak_this_)));
 }
 
 bool MediaCodecPlayer::AudioFinished() const {
   return audio_decoder_->IsCompleted() || !audio_decoder_->HasStream();
@@ skipping 25 matching lines @@
     RETURN_STRING(kStateWaitingForSurface);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media