MediaCodecPlayer - preroll and reconfiguration fixes

media/base/android/media_codec_decoder.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_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 32 matching lines @@
       decoder_thread_(decoder_thread_name),
       needs_reconfigure_(false),
       drain_decoder_(false),
       always_reconfigure_for_tests_(false),
       external_request_data_cb_(external_request_data_cb),
       starvation_cb_(starvation_cb),
       decoder_drained_cb_(decoder_drained_cb),
       stop_done_cb_(stop_done_cb),
       error_cb_(error_cb),
       state_(kStopped),
-      preroll_mode_(kPrerollTillPTS),
+      is_prepared_(false),
       eos_enqueued_(false),
       completed_(false),
       last_frame_posted_(false),
       is_data_request_in_progress_(false),
       is_incoming_data_invalid_(false),
 #ifndef NDEBUG
       verify_next_frame_is_key_(false),
 #endif
       weak_factory_(this) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
@@ skipping 24 matching lines @@
   // Flush() is a part of the Seek request. Whenever we request a seek we need
   // to invalidate the current data request.
   if (is_data_request_in_progress_)
     is_incoming_data_invalid_ = true;
 
   eos_enqueued_ = false;
   completed_ = false;
   drain_decoder_ = false;
   au_queue_.Flush();
 
+  // |is_prepared_| is set on the decoder thread, it shouldn't be running now.
+  DCHECK(!decoder_thread_.IsRunning());
+  is_prepared_ = false;
+
 #ifndef NDEBUG
   // We check and reset |verify_next_frame_is_key_| on Decoder thread.
-  // This DCHECK ensures we won't need to lock this variable.
-  DCHECK(!decoder_thread_.IsRunning());
+  // We have just DCHECKed that decoder thread is not running.
 
   // For video the first frame after flush must be key frame.
   verify_next_frame_is_key_ = true;
 #endif
 
-  preroll_mode_ = kPrerollTillPTS;
-
   if (media_codec_bridge_) {
     // MediaCodecBridge::Reset() performs MediaCodecBridge.flush()
     MediaCodecStatus flush_status = media_codec_bridge_->Reset();
     if (flush_status != MEDIA_CODEC_OK) {
       DVLOG(0) << class_name() << "::" << __FUNCTION__
                << "MediaCodecBridge::Reset() failed";
       media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
     }
   }
 }
 
 void MediaCodecDecoder::ReleaseMediaCodec() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
+  DCHECK(!decoder_thread_.IsRunning());
+
   media_codec_bridge_.reset();
-  preroll_mode_ = kPrerollTillPTS;
+
+  // |is_prepared_| is set on the decoder thread, it shouldn't be running now.
+  is_prepared_ = false;
 }
 
 bool MediaCodecDecoder::IsPrefetchingOrPlaying() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Whether decoder needs to be stopped.
   base::AutoLock lock(state_lock_);
   switch (state_) {
     case kPrefetching:
     case kPrefetched:
@@ skipping 19 matching lines @@
 
 bool MediaCodecDecoder::IsCompleted() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   return completed_;
 }
 
 bool MediaCodecDecoder::NotCompletedAndNeedsPreroll() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
-  return HasStream() && preroll_mode_ != kNoPreroll && !completed_;
+  return HasStream() && !completed_ &&
+         (!is_prepared_ || preroll_timestamp_ != base::TimeDelta());
 }
 
-void MediaCodecDecoder::SetDecodingUntilOutputIsPresent() {
+void MediaCodecDecoder::SetPrerollTimestamp(base::TimeDelta preroll_timestamp) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
-  DVLOG(1) << class_name() << "::" << __FUNCTION__;
+  DVLOG(1) << class_name() << "::" << __FUNCTION__ << ": " << preroll_timestamp;
 
-  preroll_mode_ = kPrerollTillOutputIsPresent;
+  preroll_timestamp_ = preroll_timestamp;
 }
 
 base::android::ScopedJavaLocalRef<jobject> MediaCodecDecoder::GetMediaCrypto() {
   base::android::ScopedJavaLocalRef<jobject> media_crypto;
 
   // TODO(timav): implement DRM.
   // drm_bridge_ is not implemented
   // if (drm_bridge_)
   //   media_crypto = drm_bridge_->GetMediaCrypto();
   return media_crypto;
@@ skipping 51 matching lines @@
   DCHECK(!decoder_thread_.IsRunning());
 
   // For video the first frame after reconfiguration must be key frame.
   if (result == kConfigOk)
     verify_next_frame_is_key_ = true;
 #endif
 
   return result;
 }
 
-bool MediaCodecDecoder::Preroll(base::TimeDelta preroll_timestamp,
-                                const base::Closure& preroll_done_cb) {
+bool MediaCodecDecoder::Preroll(const base::Closure& preroll_done_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__
-           << " preroll_timestamp:" << preroll_timestamp;
+           << " preroll_timestamp:" << preroll_timestamp_;
 
   DecoderState state = GetState();
   if (state != kPrefetched) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state "
              << AsString(state) << ", ignoring";
     return false;
   }
 
   if (!media_codec_bridge_) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << ": not configured, ignoring";
     return false;
   }
 
   DCHECK(!decoder_thread_.IsRunning());
-  DCHECK(preroll_mode_ != kNoPreroll);
 
   preroll_done_cb_ = preroll_done_cb;
 
   // We only synchronize video stream.
   DissociatePTSFromTime();  // associaton will happen after preroll is done.
 
-  preroll_timestamp_ = (preroll_mode_ == kPrerollTillPTS) ? preroll_timestamp
-                                                          : base::TimeDelta();
-
   last_frame_posted_ = false;
 
   // Start the decoder thread
   if (!decoder_thread_.Start()) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << ": cannot start decoder thread";
     return false;
   }
 
   SetState(kPrerolling);
@@ skipping 20 matching lines @@
   }
 
   if (!media_codec_bridge_) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << ": not configured, ignoring";
     return false;
   }
 
   // We only synchronize video stream.
   AssociateCurrentTimeWithPTS(start_timestamp);
-  preroll_timestamp_ = base::TimeDelta();
+
+  DCHECK(preroll_timestamp_ == base::TimeDelta());
 
   // Start the decoder thread
   if (!decoder_thread_.IsRunning()) {
     last_frame_posted_ = false;
     if (!decoder_thread_.Start()) {
       DVLOG(1) << class_name() << "::" << __FUNCTION__
                << ": cannot start decoder thread";
       return false;
     }
   }
@@ skipping 39 matching lines @@
       break;
     case kPrerolling:
     case kPrerolled:
       DCHECK(decoder_thread_.IsRunning());
       // Synchronous stop.
       decoder_thread_.Stop();
       SetState(kStopped);
       media_task_runner_->PostTask(FROM_HERE, stop_done_cb_);
       break;
     case kStopping:
+    case kStopped:

[Tima Vaisburd, 2015/09/03 19:55:27]

Moved kStopped here so RequestToStop will be ignore in kStopped state.

       break;  // ignore
-    case kStopped:
     case kPrefetching:
     case kPrefetched:
       // There is nothing to wait for, we can sent notification right away.
       DCHECK(!decoder_thread_.IsRunning());
       SetState(kStopped);
       media_task_runner_->PostTask(FROM_HERE, stop_done_cb_);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void MediaCodecDecoder::OnLastFrameRendered(bool eos_encountered) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__
            << " eos_encountered:" << eos_encountered;
 
   decoder_thread_.Stop();  // synchronous
 
   SetState(kStopped);
   completed_ = (eos_encountered && !drain_decoder_);
 
+  // If the stream is completed during preroll we need to report it since
+  // another stream might be running and the player waits for two callbacks.
   if (completed_ && !preroll_done_cb_.is_null()) {
+    preroll_timestamp_ = base::TimeDelta();

[liberato (no reviews please), 2015/09/04 21:59:13]

there's a kNoTimestamp that you might want to consider for this case.

[Tima Vaisburd, 2015/09/04 23:17:35]

Zero timestamp compares nicely at line 807, it was sort of intentional...

     media_task_runner_->PostTask(FROM_HERE,
                                  base::ResetAndReturn(&preroll_done_cb_));
   }
 
   if (eos_encountered && drain_decoder_) {
-    ReleaseMediaCodec();
     drain_decoder_ = false;
     eos_enqueued_ = false;
-    preroll_mode_ = kPrerollTillOutputIsPresent;
+    ReleaseMediaCodec();
     media_task_runner_->PostTask(FROM_HERE, decoder_drained_cb_);
   }
 
   media_task_runner_->PostTask(FROM_HERE, stop_done_cb_);
 }
 
 void MediaCodecDecoder::OnPrerollDone() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
-  preroll_mode_ = kNoPreroll;
+  preroll_timestamp_ = base::TimeDelta();
 
-  // The state might be kStopping.
-  if (GetState() == kPrerolling) {
+  // The state might be kStopping (?)
+  if (GetState() == kPrerolling)
     SetState(kPrerolled);
-    media_task_runner_->PostTask(FROM_HERE,
-                                 base::ResetAndReturn(&preroll_done_cb_));
-  }
+
+  if (!preroll_done_cb_.is_null())
+    base::ResetAndReturn(&preroll_done_cb_).Run();
 }
 
 void MediaCodecDecoder::OnDemuxerDataAvailable(const DemuxerData& data) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // If |data| contains an aborted data, the last AU will have kAborted status.
   bool aborted_data =
       !data.access_units.empty() &&
       data.access_units.back().status == DemuxerStream::kAborted;
 
@@ skipping 130 matching lines @@
       DVLOG(1) << class_name() << "::" << __FUNCTION__
                << ": kStopping, posting OnLastFrameRendered";
       media_task_runner_->PostTask(
           FROM_HERE, base::Bind(&MediaCodecDecoder::OnLastFrameRendered,
                                 weak_factory_.GetWeakPtr(), false));
       last_frame_posted_ = true;
     }
 
     // We can stop processing, the |au_queue_| and MediaCodec queues can freeze.
     // We only need to let finish the delayed rendering tasks.
+    DVLOG(1) << class_name() << "::" << __FUNCTION__ << " kStopping, returning";
     return;
   }
 
   DCHECK(state == kPrerolling || state == kRunning);
 
   if (!EnqueueInputBuffer())
     return;
 
   if (!DepleteOutputBufferQueue())
     return;
@@ skipping 199 matching lines @@
 
       case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
         DVLOG(2) << class_name() << "::" << __FUNCTION__
                  << " MEDIA_CODEC_OUTPUT_FORMAT_CHANGED";
         OnOutputFormatChanged();
         break;
 
       case MEDIA_CODEC_OK:
         // We got the decoded frame.
 
+        is_prepared_ = true;
+
         if (pts < preroll_timestamp_)
           render_mode = kRenderSkip;
         else if (GetState() == kPrerolling)
           render_mode = kRenderAfterPreroll;
         else
           render_mode = kRenderNow;
 
         Render(buffer_index, offset, size, render_mode, pts, eos_encountered);
 
         if (render_mode == kRenderAfterPreroll) {
@@ skipping 75 matching lines @@
     RETURN_STRING(kStopping);
     RETURN_STRING(kInEmergencyStop);
     RETURN_STRING(kError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media