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;
   media_codec_bridge_.reset();
 }
 
 void MediaCodecDecoder::Flush() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
@@ skipping 84 matching lines @@
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   if (GetState() == kError) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__ << ": wrong state kError";
     return CONFIG_FAILURE;
   }
 
   // Here I assume that OnDemuxerConfigsAvailable won't come
   // in the middle of demuxer data.
 
+  if (needs_reconfigure_) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__
+             << ": needs reconfigure, deleting MediaCodec";
+    needs_reconfigure_ = false;
+    media_codec_bridge_.reset();
+
+    // Shall we move |delayed_buffers_| from VideoDecoder to Decoder class?
+    ClearDelayedBuffers();
+  }
+
   MediaCodecDecoder::ConfigStatus result;
   if (media_codec_bridge_) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__
              << ": reconfiguration is not required, ignoring";
     result = CONFIG_OK;
   } else {
     result = ConfigureInternal();
 
 #ifndef NDEBUG
     // We check and reset |verify_next_frame_is_key_| on Decoder thread.
@@ skipping 63 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();
 }
 
 void MediaCodecDecoder::RequestToStop() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
@@ skipping 44 matching lines @@
   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.
@@ skipping 280 matching lines @@
 
   return status != MEDIA_CODEC_ERROR;
 }
 
 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