support adaptive playback in MSE

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 271 matching lines @@
   // Otherwise MediaDrm will report errors.
   if (status == MEDIA_CODEC_NO_KEY)
     input_buf_index_ = input_buf_index;
 
   return status;
 }
 
 bool MediaDecoderJob::HasData() const {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   // When |input_eos_encountered_| is set, |access_unit_index_| and
   // |current_demuxer_data_index_| must be pointing to an EOS unit.

[wolenetz, 2014/06/06 23:28:06]

nit: or a kConfigChanged unit and drain_decoder_ is true, during which we will
just feed EOS to decoder?

[qinmin, 2014/06/07 01:31:55]

Done. Rephrased the comment.

   // We'll reuse this unit to flush the decoder until we hit output EOS.
   DCHECK(!input_eos_encountered_ || !NoAccessUnitsRemainingInChunk(true));
   return !NoAccessUnitsRemainingInChunk(true) ||
       !NoAccessUnitsRemainingInChunk(false);
 }
 
 void MediaDecoderJob::RequestData(const base::Closure& done_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(data_received_cb_.is_null());
@@ skipping 22 matching lines @@
 void MediaDecoderJob::DecodeCurrentAccessUnit(
     base::TimeTicks start_time_ticks,
     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();
-    bool config_changed = SetDemuxerConfigs(
-        received_data_[index].demuxer_configs[0]);
-    if (config_changed)
+    const DemuxerConfigs& configs = received_data_[index].demuxer_configs[0];
+    bool reconfigure_needed = IsCodecReconfigureNeeded(configs);
+    if (SetDemuxerConfigs(configs))
       config_changed_cb_.Run();

[wolenetz, 2014/06/06 23:28:07]

Should we wait to tell the renderer that the config has changed until we
complete draining (if any) and create the new decoder? I'm fine with this as a
separate CL.

[qinmin, 2014/06/07 01:31:55]

Yes, that should be the correct behavior. However, the fix needs to touch
multiple places where drain_decoder_ gets cleared. Added TODO here.

On 2014/06/06 23:28:07, wolenetz wrote:

     if (!drain_decoder_) {

[wolenetz, 2014/06/06 23:28:07]

If !reconfigure_needed, we still drain previous decoder and do the old
OnDecoderDrained() logic. Or am I misreading?

[qinmin, 2014/06/07 01:31:55]

If !reconfigure_needed, we will keep the previous decoder and keep on decoding
the data it currently has. So there is no need to drain it.
However, if need_to_reconfig_decoder_job_ is true, we will recreate a new
decoder even if !reconfigure_needed is true. This could happen when surface
changes or a seek is conducted. In both cases, we should abadon the current
buffered data and recreate a new codec.


On 2014/06/06 23:28:07, wolenetz wrote:

[wolenetz, 2014/06/09 18:22:39]

Thank you for clarifying. Yes, I was misreading.

       // 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_ || !config_changed) {
+      if (skip_eos_enqueue_ || !reconfigure_needed) {
         need_to_reconfig_decoder_job_ =
-            need_to_reconfig_decoder_job_ || config_changed;
+            need_to_reconfig_decoder_job_ || reconfigure_needed;
         ui_task_runner_->PostTask(FROM_HERE, base::Bind(
             &MediaDecoderJob::OnDecodeCompleted, base::Unretained(this),
             MEDIA_CODEC_OUTPUT_FORMAT_CHANGED, kNoTimestamp(), kNoTimestamp()));
         return;
       }
       // Start draining the decoder so that all the remaining frames are
       // rendered.
       drain_decoder_ = true;
     }
   }
@@ skipping 270 matching lines @@
   base::android::ScopedJavaLocalRef<jobject> media_crypto = GetMediaCrypto();
   if (is_content_encrypted_ && media_crypto.is_null())
     return false;
 
   ReleaseMediaCodecBridge();
   DVLOG(1) << __FUNCTION__ << " : creating new media codec bridge";
 
   return CreateMediaCodecBridgeInternal();
 }
 
+bool MediaDecoderJob::IsCodecReconfigureNeeded(
+    const DemuxerConfigs& configs) const {
+  if (!AreDemuxerConfigsChanged(configs))
+    return false;
+  return true;
+}
+
 void MediaDecoderJob::ReleaseMediaCodecBridge() {
   if (!media_codec_bridge_)
     return;
 
   media_codec_bridge_.reset();
   OnMediaCodecBridgeReleased();
 }
 
 }  // namespace media