MediaCodecPlayer implementation (stage 5 - reconfiguration)

media/base/android/media_codec_video_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_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/buffers.h"
 #include "media/base/demuxer_stream.h"
 
 namespace media {
 
 namespace {
 const int kDelayForStandAloneEOS = 2;  // milliseconds
 }
 
 MediaCodecVideoDecoder::MediaCodecVideoDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const base::Closure& request_data_cb,
     const base::Closure& starvation_cb,
+    const base::Closure& decoder_drained_cb,
     const base::Closure& stop_done_cb,
     const base::Closure& error_cb,
     const SetTimeCallback& update_current_time_cb,
     const VideoSizeChangedCallback& video_size_changed_cb,
     const base::Closure& codec_created_cb)
     : MediaCodecDecoder(media_task_runner,
                         request_data_cb,
                         starvation_cb,
+                        decoder_drained_cb,
                         stop_done_cb,
                         error_cb,
                         "VideoDecoder"),
       update_current_time_cb_(update_current_time_cb),
       video_size_changed_cb_(video_size_changed_cb),
       codec_created_cb_(codec_created_cb) {
 }
 
 MediaCodecVideoDecoder::~MediaCodecVideoDecoder() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "VideoDecoder::~VideoDecoder()";
   ReleaseDecoderResources();
 }
 
 const char* MediaCodecVideoDecoder::class_name() const {
   return "VideoDecoder";
 }
 
 bool MediaCodecVideoDecoder::HasStream() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   return configs_.video_codec != kUnknownVideoCodec;
 }
 
 void MediaCodecVideoDecoder::SetDemuxerConfigs(const DemuxerConfigs& configs) {
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
-
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " " << configs;
 
   configs_ = configs;
 
   if (video_size_.IsEmpty()) {
     video_size_ = configs_.video_size;
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(video_size_changed_cb_, video_size_));
   }
 }
@@ skipping 27 matching lines @@
   needs_reconfigure_ = true;
 }
 
 bool MediaCodecVideoDecoder::HasVideoSurface() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   return !surface_.IsEmpty();
 }
 
 bool MediaCodecVideoDecoder::IsCodecReconfigureNeeded(
-    const DemuxerConfigs& curr,
     const DemuxerConfigs& next) const {
-  if (curr.video_codec != next.video_codec ||
-      curr.is_video_encrypted != next.is_video_encrypted) {
+  if (always_reconfigure_for_tests_)
+    return true;
+
+  if (configs_.video_codec != next.video_codec ||
+      configs_.is_video_encrypted != next.is_video_encrypted) {
     return true;
   }
 
   // Only size changes below this point
 
-  if (curr.video_size.width() == next.video_size.width() &&
-      curr.video_size.height() == next.video_size.height()) {
-    return false;  // i.e. curr == next
+  if (configs_.video_size.width() == next.video_size.width() &&
+      configs_.video_size.height() == next.video_size.height()) {
+    return false;  // i.e. configs_ == next
   }
 
   return !static_cast<VideoCodecBridge*>(media_codec_bridge_.get())
       ->IsAdaptivePlaybackSupported(next.video_size.width(),
                                     next.video_size.height());
 }
 
 MediaCodecDecoder::ConfigStatus MediaCodecVideoDecoder::ConfigureInternal() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
@@ skipping 32 matching lines @@
   if (!media_codec_bridge_) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__
              << " failed: cannot create video codec";
     return kConfigFailure;
   }
 
   DVLOG(0) << class_name() << "::" << __FUNCTION__ << " succeeded";
 
   media_task_runner_->PostTask(FROM_HERE, codec_created_cb_);
 
+  if (!codec_created_for_tests_cb_.is_null())
+    media_task_runner_->PostTask(FROM_HERE, codec_created_for_tests_cb_);
+
   return kConfigOk;
 }
 
 void MediaCodecVideoDecoder::AssociateCurrentTimeWithPTS(base::TimeDelta pts) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " pts:" << pts;
 
   start_time_ticks_ = base::TimeTicks::Now();
   start_pts_ = pts;
@@ skipping 137 matching lines @@
 
   // |update_current_time_cb_| might be null if there is audio stream.
   // Do not update current time for stand-alone EOS frames.
   if (!update_current_time_cb_.is_null() && update_time) {
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(update_current_time_cb_, pts, pts, false));
   }
 }
 
 }  // namespace media