Let only seeks reset Android MSE stream playback completion

media/base/android/media_decoder_job.cc

 // Copyright 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_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 10 matching lines @@
 
 MediaDecoderJob::MediaDecoderJob(
     const scoped_refptr<base::MessageLoopProxy>& decoder_loop,
     MediaCodecBridge* media_codec_bridge,
     const base::Closure& request_data_cb)
     : ui_loop_(base::MessageLoopProxy::current()),
       decoder_loop_(decoder_loop),
       media_codec_bridge_(media_codec_bridge),
       needs_flush_(false),
       input_eos_encountered_(false),
+      output_eos_encountered_(false),
       skip_eos_enqueue_(true),
       prerolling_(true),
       weak_this_(this),
       request_data_cb_(request_data_cb),
       access_unit_index_(0),
       input_buf_index_(-1),
       stop_decode_pending_(false),
       destroy_pending_(false) {
 }
 
@@ skipping 227 matching lines @@
     const base::TimeDelta& start_presentation_timestamp,
     bool needs_flush,
     const MediaDecoderJob::DecoderCallback& callback) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(decoder_loop_->BelongsToCurrentThread());
   TRACE_EVENT0("media", __FUNCTION__);
 
   if (needs_flush) {
     DVLOG(1) << "DecodeInternal needs flush.";
     input_eos_encountered_ = false;
+    output_eos_encountered_ = false;
     MediaCodecStatus reset_status = media_codec_bridge_->Reset();
     if (MEDIA_CODEC_OK != reset_status) {
       callback.Run(reset_status, kNoTimestamp(), 0);
       return;
     }
   }
 
+  // Once output EOS has occurred, we should not be asked to decode again.
+  // MediaCodec has undefined behavior if similarly asked to decode after output
+  // EOS.
+  DCHECK(!output_eos_encountered_);
+
   // For aborted access unit, just skip it and inform the player.
   if (unit.status == DemuxerStream::kAborted) {
     // TODO(qinmin): use a new enum instead of MEDIA_CODEC_STOPPED.
     callback.Run(MEDIA_CODEC_STOPPED, kNoTimestamp(), 0);
     return;
   }
 
   if (skip_eos_enqueue_) {
     if (unit.end_of_stream || unit.data.empty()) {
       input_eos_encountered_ = true;
+      output_eos_encountered_ = true;
       callback.Run(MEDIA_CODEC_OUTPUT_END_OF_STREAM, kNoTimestamp(), 0);
       return;
     }
 
     skip_eos_enqueue_ = false;
   }
 
-
   MediaCodecStatus input_status = MEDIA_CODEC_INPUT_END_OF_STREAM;
   if (!input_eos_encountered_) {
     input_status = QueueInputBuffer(unit);
     if (input_status == MEDIA_CODEC_INPUT_END_OF_STREAM) {
       input_eos_encountered_ = true;
     } else if (input_status != MEDIA_CODEC_OK) {
       callback.Run(input_status, kNoTimestamp(), 0);
       return;
     }
   }
 
   int buffer_index = 0;
   size_t offset = 0;
   size_t size = 0;
   base::TimeDelta presentation_timestamp;
-  bool output_eos_encountered = false;
 
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
       kMediaCodecTimeoutInMilliseconds);
 
   MediaCodecStatus status =
       media_codec_bridge_->DequeueOutputBuffer(timeout,
                                                &buffer_index,
                                                &offset,
                                                &size,
                                                &presentation_timestamp,
-                                               &output_eos_encountered,
+                                               &output_eos_encountered_,
                                                NULL);
 
   if (status != MEDIA_CODEC_OK) {
     if (status == MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED &&
         !media_codec_bridge_->GetOutputBuffers()) {
       status = MEDIA_CODEC_ERROR;
     }
     callback.Run(status, kNoTimestamp(), 0);
     return;
   }
 
   // TODO(xhwang/qinmin): This logic is correct but strange. Clean it up.
-  if (output_eos_encountered)
+  if (output_eos_encountered_)
     status = MEDIA_CODEC_OUTPUT_END_OF_STREAM;
   else if (input_status == MEDIA_CODEC_INPUT_END_OF_STREAM)
     status = MEDIA_CODEC_INPUT_END_OF_STREAM;
 
   // Check whether we need to render the output.
   // TODO(qinmin): comparing most recently queued input's |unit.timestamp| with
   // |preroll_timestamp_| is not accurate due to data reordering and possible
   // input queueing without immediate dequeue when |input_status| !=
   // |MEDIA_CODEC_OK|. Need to use the |presentation_timestamp| for video, and
   // use |size| to calculate the timestamp for audio. See
@@ skipping 70 matching lines @@
       // Do nothing.
       break;
   };
 
   stop_decode_pending_ = false;
   base::ResetAndReturn(&decode_cb_).Run(status, presentation_timestamp,
                                         audio_output_bytes);
 }
 
 }  // namespace media