MediaCodecPlayer implementation (stage 5 - reconfiguration)

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 480 matching lines @@
 
   duration_ = duration;
 }
 
 void MediaCodecPlayer::SetDecodersTimeCallbackForTests(
     DecodersTimeCallback cb) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   decoders_time_cb_ = cb;
 }
 
+void MediaCodecPlayer::SetCodecCreatedCallbackForTests(
+    CodecCreatedCallback cb) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(audio_decoder_ && video_decoder_);
+
+  audio_decoder_->SetCodecCreatedCallbackForTests(
+      base::Bind(cb, DemuxerStream::AUDIO));
+  video_decoder_->SetCodecCreatedCallbackForTests(
+      base::Bind(cb, DemuxerStream::VIDEO));
+}
+
+void MediaCodecPlayer::SetAlwaysReconfigureForTests(DemuxerStream::Type type) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DCHECK(audio_decoder_ && video_decoder_);
+
+  if (type == DemuxerStream::AUDIO)
+    audio_decoder_->SetAlwaysReconfigureForTests();
+  else if (type == DemuxerStream::VIDEO)
+    video_decoder_->SetAlwaysReconfigureForTests();
+}
+
 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;
@@ skipping 74 matching lines @@
 
 void MediaCodecPlayer::OnPrerollDone() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   StartStatus status = StartDecoders();
   if (status != kStartOk)
     GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
 }
 
-void MediaCodecPlayer::OnStopDone() {
+void MediaCodecPlayer::OnDecoderDrained(DemuxerStream::Type type) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__ << " " << type;
+
+  // We expect that OnStopDone() comes next.
+
+  DCHECK(type == DemuxerStream::AUDIO || type == DemuxerStream::VIDEO);
+  DCHECK(state_ == kStatePlaying || state_ == kStateStopping)
+      << __FUNCTION__ << " illegal state: " << AsString(state_);
+
+  switch (state_) {
+    case kStatePlaying:
+      SetState(kStateStopping);
+      SetPendingStart(true);
+
+      if (type == DemuxerStream::AUDIO && !VideoFinished()) {
+        DVLOG(1) << __FUNCTION__ << " requesting to stop video";
+        video_decoder_->SetPrerollTillNextFrame();
+        video_decoder_->RequestToStop();
+      } else if (type == DemuxerStream::VIDEO && !AudioFinished()) {
+        DVLOG(1) << __FUNCTION__ << " requesting to stop audio";
+        audio_decoder_->SetPrerollTillNextFrame();
+        audio_decoder_->RequestToStop();
+      }
+      break;
+
+    case kStateStopping:
+      if (type == DemuxerStream::AUDIO && !VideoFinished())
+        video_decoder_->SetPrerollTillNextFrame();
+      else if (type == DemuxerStream::VIDEO && !AudioFinished())
+        audio_decoder_->SetPrerollTillNextFrame();
+      break;
+
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void MediaCodecPlayer::OnStopDone(DemuxerStream::Type type) {
+  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__ << " " << type
+           << " interpolated time:" << GetInterpolatedTime();
 
   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();
@@ skipping 385 matching lines @@
   bool do_audio = false;
   bool do_video = false;
 
   if (audio_decoder_->IsPrefetchingOrPlaying())
     do_audio = true;
   if (video_decoder_->IsPrefetchingOrPlaying())
     do_video = true;
 
   if (!do_audio && !do_video) {
     GetMediaTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_));
+        FROM_HERE, base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
+                              DemuxerStream::UNKNOWN));
     return;
   }
 
   if (do_audio)
     audio_decoder_->RequestToStop();
   if (do_video)
     video_decoder_->RequestToStop();
 }
 
 void MediaCodecPlayer::RequestDemuxerSeek(base::TimeDelta seek_time,
@@ skipping 32 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::OnStopDone, media_weak_this_),
+      base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
+                 DemuxerStream::AUDIO),
+      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
+                 DemuxerStream::AUDIO),
       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::OnStopDone, media_weak_this_),
+      base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
+                 DemuxerStream::VIDEO),
+      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
+                 DemuxerStream::VIDEO),
       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 24 matching lines @@
     RETURN_STRING(kStateWaitingForSurface);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media