Remove the IPC to request DemuxerConfigs when config changes

media/base/android/media_source_player.cc

 // Copyright (c) 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_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 282 matching lines @@
   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::OnDemuxerConfigsAvailable(
     const DemuxerConfigs& configs) {
   DVLOG(1) << __FUNCTION__;
   duration_ = configs.duration;
   clock_.SetDuration(duration_);
 
-  audio_codec_ = configs.audio_codec;
-  num_channels_ = configs.audio_channels;
-  sampling_rate_ = configs.audio_sampling_rate;
-  is_audio_encrypted_ = configs.is_audio_encrypted;
-  audio_extra_data_ = configs.audio_extra_data;
-  video_codec_ = configs.video_codec;
-  width_ = configs.video_size.width();
-  height_ = configs.video_size.height();
-  is_video_encrypted_ = configs.is_video_encrypted;
+  SetDemuxerConfigs(configs, true);
+  SetDemuxerConfigs(configs, false);
 
   manager()->OnMediaMetadataChanged(
       player_id(), duration_, width_, height_, true);
-
-  if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) {
-    if (reconfig_audio_decoder_)
-      ConfigureAudioDecoderJob();
-
-    if (reconfig_video_decoder_)
-      ConfigureVideoDecoderJob();
-
-    ClearPendingEvent(CONFIG_CHANGE_EVENT_PENDING);
-
-    // Resume decoding after the config change if we are still playing.
-    if (playing_)
-      StartInternal();
-  }
 }
 
 void MediaSourcePlayer::OnDemuxerDataAvailable(const DemuxerData& data) {
   DVLOG(1) << __FUNCTION__ << "(" << data.type << ")";
   DCHECK_LT(0u, data.access_units.size());
 
   if (has_pending_audio_data_request_ && data.type == DemuxerStream::AUDIO) {
     has_pending_audio_data_request_ = false;
     ProcessPendingEvents();
     return;
@@ skipping 150 matching lines @@
     if (audio_decoder_job_)
       audio_decoder_job_->SetBaseTimestamp(GetCurrentTime());
     demuxer_->RequestDemuxerSeek(GetCurrentTime(), doing_browser_seek_);
     return;
   }
 
   start_time_ticks_ = base::TimeTicks();
   if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) {
     DVLOG(1) << __FUNCTION__ << " : Handling CONFIG_CHANGE_EVENT.";
     DCHECK(reconfig_audio_decoder_ || reconfig_video_decoder_);
-    demuxer_->RequestDemuxerConfigs();
-    return;
+    manager()->OnMediaMetadataChanged(
+         player_id(), duration_, width_, height_, true);
+
+    if (reconfig_audio_decoder_)
+      ConfigureAudioDecoderJob();
+
+    if (reconfig_video_decoder_)
+      ConfigureVideoDecoderJob();
+
+    ClearPendingEvent(CONFIG_CHANGE_EVENT_PENDING);
   }
 
   if (IsEventPending(SURFACE_CHANGE_EVENT_PENDING)) {
     DVLOG(1) << __FUNCTION__ << " : Handling SURFACE_CHANGE_EVENT.";
     // Setting a new surface will require a new MediaCodec to be created.
     ResetVideoDecoderJob();
     ConfigureVideoDecoderJob();
 
     // Return early if we can't successfully configure a new video decoder job
     // yet.
     if (HasVideo() && !video_decoder_job_)
       return;
   }
 
   if (IsEventPending(PREFETCH_REQUEST_EVENT_PENDING)) {
     DVLOG(1) << __FUNCTION__ << " : Handling PREFETCH_REQUEST_EVENT.";
     // If one of the decoder is not initialized, cancel this event as it will be
     // called later when Start() is called again.
     if ((HasVideo() && !video_decoder_job_) ||
         (HasAudio() && !audio_decoder_job_)) {
       ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
       return;
     }
 
     DCHECK(audio_decoder_job_ || AudioFinished());
     DCHECK(video_decoder_job_ || VideoFinished());
-
     int count = (AudioFinished() ? 0 : 1) + (VideoFinished() ? 0 : 1);
 
     // It is possible that all streams have finished decode, yet starvation
     // occurred during the last stream's EOS decode. In this case, prefetch is a
     // no-op.
     ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
     if (count == 0)
       return;
 
     SetPendingEvent(PREFETCH_DONE_EVENT_PENDING);
@@ skipping 104 matching lines @@
     // If we have a valid timestamp, start the starvation callback. Otherwise,
     // reset the |start_time_ticks_| so that the next frame will not suffer
     // from the decoding delay caused by the current frame.
     if (current_presentation_timestamp != kNoTimestamp())
       StartStarvationCallback(current_presentation_timestamp,
                               max_presentation_timestamp);
     else
       start_time_ticks_ = base::TimeTicks::Now();
   }
 
-  if (is_audio) {
+  if (is_audio)
     DecodeMoreAudio();
-    return;
-  }
+  else
+    DecodeMoreVideo();
 
-  DecodeMoreVideo();
+  if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING))
+    ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::DecodeMoreAudio() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!audio_decoder_job_->is_decoding());
   DCHECK(!AudioFinished());
 
   if (audio_decoder_job_->Decode(
           start_time_ticks_,
           start_presentation_timestamp_,
           base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
                      weak_factory_.GetWeakPtr(),
                      true))) {
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreAudio",
                              audio_decoder_job_.get());
     return;
   }
 
   // Failed to start the next decode.
   // Wait for demuxer ready message.
   DCHECK(!reconfig_audio_decoder_);
   reconfig_audio_decoder_ = true;
+  DemuxerConfigs* configs = audio_decoder_job_->GetDemuxerConfigs();
+  DCHECK(configs);
+  SetDemuxerConfigs(*configs, true);
 
   // Config change may have just been detected on the other stream. If so,
   // don't send a duplicate demuxer config request.
   if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) {
     DCHECK(reconfig_video_decoder_);
     return;
   }
 
   SetPendingEvent(CONFIG_CHANGE_EVENT_PENDING);
-  ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::DecodeMoreVideo() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!video_decoder_job_->is_decoding());
   DCHECK(!VideoFinished());
 
   if (video_decoder_job_->Decode(
           start_time_ticks_,
           start_presentation_timestamp_,
           base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
                      weak_factory_.GetWeakPtr(),
                      false))) {
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreVideo",
                              video_decoder_job_.get());
     return;
   }
 
   // Failed to start the next decode.
   // Wait for demuxer ready message.
 
   // After this detection of video config change, next video data received
   // will begin with I-frame.
   next_video_data_is_iframe_ = true;
 
   DCHECK(!reconfig_video_decoder_);
   reconfig_video_decoder_ = true;
+  DemuxerConfigs* configs = video_decoder_job_->GetDemuxerConfigs();
+  DCHECK(configs);
+  SetDemuxerConfigs(*configs, false);
 
   // Config change may have just been detected on the other stream. If so,
   // don't send a duplicate demuxer config request.
   if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) {
     DCHECK(reconfig_audio_decoder_);
     return;
   }
 
   SetPendingEvent(CONFIG_CHANGE_EVENT_PENDING);
-  ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::PlaybackCompleted(bool is_audio) {
   DVLOG(1) << __FUNCTION__ << "(" << is_audio << ")";
   if (is_audio)
     reached_audio_eos_ = true;
   else
     reached_video_eos_ = true;
 
   if (AudioFinished() && VideoFinished()) {
@@ skipping 230 matching lines @@
   start_time_ticks_ = base::TimeTicks::Now();
   start_presentation_timestamp_ = GetCurrentTime();
   if (!clock_.IsPlaying())
     clock_.Play();
 
   if (!AudioFinished())
     DecodeMoreAudio();
 
   if (!VideoFinished())
     DecodeMoreVideo();
+
+  if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING))
+    ProcessPendingEvents();
 }
 
 const char* MediaSourcePlayer::GetEventName(PendingEventFlags event) {
   static const char* kPendingEventNames[] = {
     "SEEK",
     "SURFACE_CHANGE",
     "CONFIG_CHANGE",
     "PREFETCH_REQUEST",
     "PREFETCH_DONE",
   };
@@ skipping 20 matching lines @@
 }
 
 void MediaSourcePlayer::ClearPendingEvent(PendingEventFlags event) {
   DVLOG(1) << __FUNCTION__ << "(" << GetEventName(event) << ")";
   DCHECK_NE(event, NO_EVENT_PENDING);
   DCHECK(IsEventPending(event)) << GetEventName(event);
 
   pending_event_ &= ~event;
 }
 
+void MediaSourcePlayer::SetDemuxerConfigs(const DemuxerConfigs& configs,
+                                          bool is_audio) {
+  if (is_audio) {
+    audio_codec_ = configs.audio_codec;
+    num_channels_ = configs.audio_channels;
+    sampling_rate_ = configs.audio_sampling_rate;
+    is_audio_encrypted_ = configs.is_audio_encrypted;
+    audio_extra_data_ = configs.audio_extra_data;
+  } else {
+    video_codec_ = configs.video_codec;
+    width_ = configs.video_size.width();
+    height_ = configs.video_size.height();
+    is_video_encrypted_ = configs.is_video_encrypted;
+  }
+}
+
 }  // namespace media