MediaCodecPlayer implementation (stage 3 - browser seek and surface change)

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 22 matching lines @@
 
 MediaCodecDecoder::MediaCodecDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const base::Closure& external_request_data_cb,
     const base::Closure& starvation_cb,
     const base::Closure& stop_done_cb,
     const base::Closure& error_cb,
     const char* decoder_thread_name)
     : media_task_runner_(media_task_runner),
       decoder_thread_(decoder_thread_name),
+      needs_reconfigure_(false),
       external_request_data_cb_(external_request_data_cb),
       starvation_cb_(starvation_cb),
       stop_done_cb_(stop_done_cb),
       error_cb_(error_cb),
       state_(kStopped),
       eos_enqueued_(false),
       completed_(false),
       last_frame_posted_(false),
       is_data_request_in_progress_(false),
       is_incoming_data_invalid_(false),
@@ skipping 22 matching lines @@
 
 const char* MediaCodecDecoder::class_name() const {
   return "Decoder";
 }
 
 void MediaCodecDecoder::ReleaseDecoderResources() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
+  // Set [kInEmergencyStop| state to block already posted ProcessNextFrame().
+  SetState(kInEmergencyStop);
+
   decoder_thread_.Stop();  // synchronous
-  state_ = kStopped;
+
+  SetState(kStopped);
   media_codec_bridge_.reset();
 }
 
 void MediaCodecDecoder::Flush() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DCHECK_EQ(GetState(), kStopped);
 
@@ skipping 76 matching lines @@
   PrefetchNextChunk();
 }
 
 MediaCodecDecoder::ConfigStatus MediaCodecDecoder::Configure() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   if (GetState() == kError) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state kError";
-    return CONFIG_FAILURE;
+    return kConfigFailure;
+  }
+
+  if (needs_reconfigure_) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__
+             << ": needs reconfigure, deleting MediaCodec";
+    needs_reconfigure_ = false;
+    media_codec_bridge_.reset();
+
+    // No need to release these buffers since the MediaCodec is deleted, just
+    // remove their indexes from |delayed_buffers_|.
+
+    ClearDelayedBuffers(false);
   }
 
   MediaCodecDecoder::ConfigStatus result;
   if (media_codec_bridge_) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__
              << ": reconfiguration is not required, ignoring";
-    result = CONFIG_OK;
+    result = kConfigOk;
   } else {
     result = ConfigureInternal();
 
 #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());
 
     // For video the first frame after reconfiguration must be key frame.
-    if (result == CONFIG_OK)
+    if (result == kConfigOk)
       verify_next_frame_is_key_ = true;
 #endif
   }
 
   return result;
 }
 
 bool MediaCodecDecoder::Start(base::TimeDelta current_time) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__
            << " current_time:" << current_time;
 
   DecoderState state = GetState();
   if (state == kRunning) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__ << ": already started";
     return true;  // already started
   }
 
   if (state != kPrefetched) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state "
-             << AsString(state) << " ignoring";
+             << AsString(state) << ", ignoring";
     return false;
   }
 
   if (!media_codec_bridge_) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << ": not configured, ignoring";
     return false;
   }
 
   DCHECK(!decoder_thread_.IsRunning());
@@ skipping 26 matching lines @@
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   if (GetState() == kError) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << ": wrong state kError, ignoring";
     return;
   }
 
   // After this method returns, decoder thread will not be running.
 
+  // Set [kInEmergencyStop| state to block already posted ProcessNextFrame().
+  SetState(kInEmergencyStop);
+
   decoder_thread_.Stop();  // synchronous
-  state_ = kStopped;
 
-  // Shall we move |delayed_buffers_| from VideoDecoder to Decoder class?
-  ReleaseDelayedBuffers();
+  SetState(kStopped);
+
+  ClearDelayedBuffers(true);  // release prior to clearing  |delayed_buffers_|.
 }
 
 void MediaCodecDecoder::RequestToStop() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   DecoderState state = GetState();
   switch (state) {
     case kError:
@@ skipping 19 matching lines @@
   }
 }
 
 void MediaCodecDecoder::OnLastFrameRendered(bool completed) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__
            << " completed:" << completed;
 
   decoder_thread_.Stop();  // synchronous
-  state_ = kStopped;
+
+  SetState(kStopped);
   completed_ = completed;
 
   media_task_runner_->PostTask(FROM_HERE, stop_done_cb_);
 }
 
 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;
 
 #ifndef NDEBUG
   const char* explain_if_skipped =
       is_incoming_data_invalid_ ? " skipped as invalid"
                                 : (aborted_data ? " skipped as aborted" : "");
 
   for (const auto& unit : data.access_units)
-    DVLOG(1) << class_name() << "::" << __FUNCTION__ << explain_if_skipped
+    DVLOG(2) << class_name() << "::" << __FUNCTION__ << explain_if_skipped
              << " au: " << unit;
   for (const auto& configs : data.demuxer_configs)
-    DVLOG(1) << class_name() << "::" << __FUNCTION__ << " configs: " << configs;
+    DVLOG(2) << class_name() << "::" << __FUNCTION__ << " configs: " << configs;
 #endif
 
   if (!is_incoming_data_invalid_ && !aborted_data)
     au_queue_.PushBack(data);
 
   is_incoming_data_invalid_ = false;
   is_data_request_in_progress_ = false;
 
   // Do not request data if we got kAborted. There is no point to request the
   // data after kAborted and before the OnDemuxerSeekDone.
-  if (state_ == kPrefetching && !aborted_data)
+  if (GetState() == kPrefetching && !aborted_data)
     PrefetchNextChunk();
 }
 
 int MediaCodecDecoder::NumDelayedRenderTasks() const {
   return 0;
 }
 
 void MediaCodecDecoder::CheckLastFrame(bool eos_encountered,
                                        bool has_delayed_tasks) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   bool last_frame_when_stopping = GetState() == kStopping && !has_delayed_tasks;
 
   if (last_frame_when_stopping || eos_encountered) {
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(&MediaCodecDecoder::OnLastFrameRendered,
                               weak_factory_.GetWeakPtr(), eos_encountered));
     last_frame_posted_ = true;
   }
 }
 
 void MediaCodecDecoder::OnCodecError() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
+  // Ignore codec errors from the moment surface is changed till the
+  // |media_codec_bridge_| is deleted.
+  if (needs_reconfigure_) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__
+             << ": needs reconfigure, ignoring";
+    return;
+  }
+
   SetState(kError);
   error_cb_.Run();
 }
 
 void MediaCodecDecoder::RequestData() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Ensure one data request at a time.
   if (!is_data_request_in_progress_) {
     is_data_request_in_progress_ = true;
@@ skipping 45 matching lines @@
     // We can stop processing, the |au_queue_| and MediaCodec queues can freeze.
     // We only need to let finish the delayed rendering tasks.
     return;
   }
 
   DCHECK(state == kRunning);
 
   if (!EnqueueInputBuffer())
     return;
 
-  bool eos_encountered = false;
-  if (!DepleteOutputBufferQueue(&eos_encountered))
+  if (!DepleteOutputBufferQueue())
     return;
 
-  if (eos_encountered) {
-    DVLOG(1) << class_name() << "::" << __FUNCTION__
-             << " EOS dequeued, stopping frame processing";
-    return;
-  }
-
   // We need a small delay if we want to stop this thread by
   // decoder_thread_.Stop() reliably.
   // The decoder thread message loop processes all pending
   // (but not delayed) tasks before it can quit; without a delay
   // the message loop might be forever processing the pendng tasks.
   decoder_thread_.task_runner()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&MediaCodecDecoder::ProcessNextFrame, base::Unretained(this)),
       base::TimeDelta::FromMilliseconds(kNextFrameDelay));
 }
@@ skipping 102 matching lines @@
     media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
     return false;
   }
 
   // Have successfully queued input buffer, go to next access unit.
   au_queue_.Advance();
   return true;
 }
 
 // Returns false if there was MediaCodec error.
-bool MediaCodecDecoder::DepleteOutputBufferQueue(bool* eos_encountered) {
+bool MediaCodecDecoder::DepleteOutputBufferQueue() {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   DVLOG(2) << class_name() << "::" << __FUNCTION__;
 
   int buffer_index = 0;
   size_t offset = 0;
   size_t size = 0;
   base::TimeDelta pts;
   MediaCodecStatus status;
+  bool eos_encountered = false;
 
   base::TimeDelta timeout =
       base::TimeDelta::FromMilliseconds(kOutputBufferTimeout);
 
   // Extract all output buffers that are available.
   // Usually there will be only one, but sometimes it is preceeded by
   // MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED or MEDIA_CODEC_OUTPUT_FORMAT_CHANGED.
   do {
     status = media_codec_bridge_->DequeueOutputBuffer(
-        timeout, &buffer_index, &offset, &size, &pts, eos_encountered, nullptr);
+        timeout, &buffer_index, &offset, &size, &pts, &eos_encountered,
+        nullptr);
 
     // Reset the timeout to 0 for the subsequent DequeueOutputBuffer() calls
     // to quickly break the loop after we got all currently available buffers.
     timeout = base::TimeDelta::FromMilliseconds(0);
 
     switch (status) {
       case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
         // Output buffers are replaced in MediaCodecBridge, nothing to do.
         break;
 
       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
-        Render(buffer_index, size, true, pts, *eos_encountered);
+        Render(buffer_index, size, true, pts, eos_encountered);
         break;
 
       case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
         // Nothing to do.
         break;
 
       case MEDIA_CODEC_ERROR:
         DVLOG(0) << class_name() << "::" << __FUNCTION__
                  << ": MEDIA_CODEC_ERROR from DequeueOutputBuffer";
         media_task_runner_->PostTask(FROM_HERE, internal_error_cb_);
         break;
 
       default:
         NOTREACHED();
         break;
     }
 
   } while (status != MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER &&
-           status != MEDIA_CODEC_ERROR && !*eos_encountered);
+           status != MEDIA_CODEC_ERROR && !eos_encountered);
 
-  return status != MEDIA_CODEC_ERROR;
+  if (eos_encountered) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__
+             << " EOS dequeued, stopping frame processing";
+    return false;
+  }
+
+  if (status == MEDIA_CODEC_ERROR) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__
+             << " MediaCodec error, stopping frame processing";
+    return false;
+  }
+
+  return true;
 }
 
 MediaCodecDecoder::DecoderState MediaCodecDecoder::GetState() const {
   base::AutoLock lock(state_lock_);
   return state_;
 }
 
 void MediaCodecDecoder::SetState(DecoderState state) {
-  DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << state;
+  DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << AsString(state);
 
   base::AutoLock lock(state_lock_);
   state_ = state;
 }
 
 #undef RETURN_STRING
 #define RETURN_STRING(x) \
   case x:                \
     return #x;
 
 const char* MediaCodecDecoder::AsString(DecoderState state) {
   switch (state) {
     RETURN_STRING(kStopped);
     RETURN_STRING(kPrefetching);
     RETURN_STRING(kPrefetched);
     RETURN_STRING(kRunning);
     RETURN_STRING(kStopping);
+    RETURN_STRING(kInEmergencyStop);
     RETURN_STRING(kError);
     default:
       return "Unknown DecoderState";
   }
 }
 
 #undef RETURN_STRING
 
 }  // namespace media