Send metadata change to renderer after decoder is drained

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_proxy.h"
@@ skipping 185 matching lines @@
     // Since the decoder job is not decoding data, we can safely destroy
     // |media_codec_bridge_|.
     ReleaseMediaCodecBridge();
     return;
   }
 
   // Release |media_codec_bridge_| once decoding is completed.
   release_resources_pending_ = true;
 }
 
-bool MediaDecoderJob::SetDemuxerConfigs(const DemuxerConfigs& configs) {
-  bool config_changed = AreDemuxerConfigsChanged(configs);
-  if (config_changed)
-    UpdateDemuxerConfigs(configs);
-  return config_changed;
-}
-
 base::android::ScopedJavaLocalRef<jobject> MediaDecoderJob::GetMediaCrypto() {
   base::android::ScopedJavaLocalRef<jobject> media_crypto;
   if (drm_bridge_)
     media_crypto = drm_bridge_->GetMediaCrypto();
   return media_crypto;
 }
 
 void MediaDecoderJob::Release() {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
@@ skipping 105 matching lines @@
     base::TimeDelta start_presentation_timestamp) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(!decode_cb_.is_null());
 
   RequestCurrentChunkIfEmpty();
   const AccessUnit& access_unit = CurrentAccessUnit();
   if (CurrentAccessUnit().status == DemuxerStream::kConfigChanged) {
     int index = CurrentReceivedDataChunkIndex();
     const DemuxerConfigs& configs = received_data_[index].demuxer_configs[0];
     bool reconfigure_needed = IsCodecReconfigureNeeded(configs);
-    // TODO(qinmin): |config_changed_cb_| should be run after draining finishes.
-    // http://crbug.com/381975.
-    if (SetDemuxerConfigs(configs))
-      config_changed_cb_.Run();
+    SetDemuxerConfigs(configs);
     if (!drain_decoder_) {
       // If we haven't decoded any data yet, just skip the current access unit
       // and request the MediaCodec to be recreated on next Decode().
       if (skip_eos_enqueue_ || !reconfigure_needed) {
         need_to_reconfig_decoder_job_ =
             need_to_reconfig_decoder_job_ || reconfigure_needed;
+        // Report MEDIA_CODEC_OK status so decoder will continue decoding and
+        // MEDIA_CODEC_OUTPUT_FORMAT_CHANGED status will come later.
         ui_task_runner_->PostTask(FROM_HERE, base::Bind(
             &MediaDecoderJob::OnDecodeCompleted, base::Unretained(this),
-            MEDIA_CODEC_OUTPUT_FORMAT_CHANGED, kNoTimestamp(), kNoTimestamp()));
+            MEDIA_CODEC_OK, kNoTimestamp(), kNoTimestamp()));
         return;
       }
       // Start draining the decoder so that all the remaining frames are
       // rendered.
       drain_decoder_ = true;
     }
   }
 

[wolenetz, 2014/10/08 19:41:33]

Is there a possibility that the first AU is kConfigChanged? If so, would
|drain_decoder| be false and the config change not be signalled to the manager?

[qinmin, 2014/10/08 22:52:41]

MEDIA_CODEC_OUTPUT_FORMAT_CHANGED is reported when decoder detects the output
format changed, and it includes the situation that decoder detects output
becomes available after creation.
So even if kConfigChanged is the first AU and MediaCodecBridge gets recreated,
we will still receive MEDIA_CODEC_OUTPUT_FORMAT_CHANGED once decoder detects
there are decoded data in the output.

On 2014/10/08 19:41:33, wolenetz wrote:

   DCHECK(!(needs_flush_ && drain_decoder_));
   decoder_task_runner_->PostTask(FROM_HERE, base::Bind(
       &MediaDecoderJob::DecodeInternal, base::Unretained(this),
       drain_decoder_ ? eos_unit_ : access_unit,
       start_time_ticks, start_presentation_timestamp, needs_flush_,
       media::BindToCurrentLoop(base::Bind(
           &MediaDecoderJob::OnDecodeCompleted, base::Unretained(this)))));
   needs_flush_ = false;
 }
 
@@ skipping 165 matching lines @@
     case MEDIA_CODEC_ERROR:
       // Do nothing.
       break;
   };
 
   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM && drain_decoder_) {
     OnDecoderDrained();
     status = MEDIA_CODEC_OK;
   }
 
+  if (status == MEDIA_CODEC_OUTPUT_FORMAT_CHANGED && UpdateOutputFormat())
+    config_changed_cb_.Run();
+
   if (release_resources_pending_) {
     ReleaseMediaCodecBridge();
     release_resources_pending_ = false;
     if (drain_decoder_)
       OnDecoderDrained();
   }
 
   stop_decode_pending_ = false;
   base::ResetAndReturn(&decode_cb_).Run(
       status, current_presentation_timestamp, max_presentation_timestamp);
@@ skipping 90 matching lines @@
 
 void MediaDecoderJob::ReleaseMediaCodecBridge() {
   if (!media_codec_bridge_)
     return;
 
   media_codec_bridge_.reset();
   input_buf_index_ = -1;
 }
 
 }  // namespace media