Enable seek in fullscreen mode for MSE impl on android

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 "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 174 matching lines @@
   codec->Start(audio_codec, sample_rate, channel_count, extra_data,
                extra_data_size, true);
   media_codec_bridge_.reset(codec.release());
   thread_.reset(new base::Thread("MediaSource_AudioDecoderThread"));
 }
 
 MediaSourcePlayer::MediaSourcePlayer(
     int player_id,
     MediaPlayerManager* manager)
     : MediaPlayerAndroid(player_id, manager),
-      pending_play_(false),
+      pending_event_(NO_EVENT_PENDING),
+      active_decoding_tasks_(0),
       width_(0),
       height_(0),
       audio_codec_(kUnknownAudioCodec),
       video_codec_(kUnknownVideoCodec),
       num_channels_(0),
       sampling_rate_(0),
       seekable_(true),
       audio_finished_(true),
       video_finished_(true),
       playing_(false),
       audio_access_unit_index_(0),
       video_access_unit_index_(0),
       waiting_for_audio_data_(false),
       waiting_for_video_data_(false),
+      use_empty_surface_(true),
       weak_this_(this) {
 }
 
 MediaSourcePlayer::~MediaSourcePlayer() {
   Release();
 }
 
 void MediaSourcePlayer::SetVideoSurface(jobject surface) {
-  video_decoder_job_.reset();
-  if (!surface) {
+  use_empty_surface_ =  surface ? false : true;
+
+  // If we haven't processed a surface change event, do so now.
+  if (active_decoding_tasks_ > 0) {
+    pending_event_ |= SURFACE_CHANGE_EVENT_PENDING;
+    // Request a seek so that the next decoder will decode an I-frame first.
+    // Or otherwise, MediaCodec might crash. See b/8950387.
+    pending_event_ |= SEEK_EVENT_PENDING;
+    ProcessPendingEvents();
     return;
   }
 
   if (HasVideo()) {
     video_decoder_job_.reset(new VideoDecoderJob(
         base::MessageLoopProxy::current(), video_codec_,
         gfx::Size(width_, height_), surface));
   }
 
-  if (pending_play_)
-    StartInternal();
-
   // Inform the fullscreen view the player is ready.
   // TODO(qinmin): refactor MediaPlayerBridge so that we have a better way
   // to inform ContentVideoView.
   OnMediaMetadataChanged(duration_, width_, height_, true);
+
+  if (pending_event_ & SURFACE_CHANGE_EVENT_PENDING) {
+    // We should already requested a seek in this case.
+    pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING;
+  } else {
+    // Perform a seek so the new decoder can get the I-frame first.
+    pending_event_ |= SEEK_EVENT_PENDING;
+    ProcessPendingEvents();
+    return;
+  }
+
+  if (playing_)
+    StartInternal();
 }
 
 void MediaSourcePlayer::Start() {
+  playing_ = true;
   if (HasAudio() && !audio_decoder_job_) {
     audio_decoder_job_.reset(new AudioDecoderJob(
         base::MessageLoopProxy::current(), audio_codec_, sampling_rate_,
         num_channels_, &audio_extra_data_[0], audio_extra_data_.size()));
   }
 
   if (HasVideo() && !video_decoder_job_) {
     // StartInternal() will be delayed until SetVideoSurface() gets called.
-    pending_play_ = true;
     return;
   }
 
   StartInternal();
 }
 
 void MediaSourcePlayer::Pause() {
-  pending_play_ = false;
   playing_ = false;
   start_wallclock_time_ = base::Time();
 }
 
 bool MediaSourcePlayer::IsPlaying() {
-  return pending_play_ || playing_;
+  return playing_;
 }
 
 int MediaSourcePlayer::GetVideoWidth() {
   return width_;
 }
 
 int MediaSourcePlayer::GetVideoHeight() {
   return height_;
 }
 
 void MediaSourcePlayer::SeekTo(base::TimeDelta timestamp) {
   last_presentation_timestamp_ = timestamp;
-  start_wallclock_time_ = base::Time();
-  last_seek_time_ = base::Time::Now();
-  if (audio_decoder_job_)
-    audio_decoder_job_->Flush();
-  if (video_decoder_job_)
-    video_decoder_job_->Flush();
-  received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
-  received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
-  audio_access_unit_index_ = 0;
-  video_access_unit_index_ = 0;
-  OnSeekComplete();
+  pending_event_ |= SEEK_EVENT_PENDING;
+  ProcessPendingEvents();
 }
 
 base::TimeDelta MediaSourcePlayer::GetCurrentTime() {
   return last_presentation_timestamp_;
 }
 
 base::TimeDelta MediaSourcePlayer::GetDuration() {
   return duration_;
 }
 
 void MediaSourcePlayer::Release() {
+  ClearDecodingData();
   audio_decoder_job_.reset();
   video_decoder_job_.reset();
+  active_decoding_tasks_ = 0;
+  playing_ = false;
+  pending_event_ = NO_EVENT_PENDING;
   ReleaseMediaResourcesFromManager();
 }
 
 void MediaSourcePlayer::SetVolume(float leftVolume, float rightVolume) {
 }
 
 bool MediaSourcePlayer::CanPause() {
   return seekable_;
 }
 
 bool MediaSourcePlayer::CanSeekForward() {
   return seekable_;
 }
 
 bool MediaSourcePlayer::CanSeekBackward() {
   return seekable_;
 }
 
 bool MediaSourcePlayer::IsPlayerReady() {
   return audio_decoder_job_ || video_decoder_job_;
 }
 
 void MediaSourcePlayer::StartInternal() {
-  if (playing_)
+  // Do nothing if the decoders are already running.
+  if (active_decoding_tasks_ > 0 || pending_event_ != NO_EVENT_PENDING)
     return;
-  playing_ = true;
 
   if (HasAudio()) {
     audio_finished_ = false;
     DecodeMoreAudio();
   }
   if (HasVideo()) {
     video_finished_ = false;
     DecodeMoreVideo();
   }
 }
 
 void MediaSourcePlayer::DemuxerReady(
     const MediaPlayerHostMsg_DemuxerReady_Params& params) {
   if (params.duration_ms == std::numeric_limits<int>::max())
     seekable_ = false;
   duration_ = base::TimeDelta::FromMilliseconds(params.duration_ms);
   width_ = params.video_size.width();
   height_ = params.video_size.height();
   num_channels_ = params.audio_channels;
   sampling_rate_ = params.audio_sampling_rate;
   audio_codec_ = params.audio_codec;
   video_codec_ = params.video_codec;
   audio_extra_data_ = params.audio_extra_data;
   OnMediaMetadataChanged(duration_, width_, height_, true);
 }
 
 void MediaSourcePlayer::ReadFromDemuxerAck(
     const MediaPlayerHostMsg_ReadFromDemuxerAck_Params& params) {
+  if (params.type == DemuxerStream::AUDIO)
+    waiting_for_audio_data_ = false;
+  else
+    waiting_for_video_data_ = false;
+
+  // If there is a pending seek request, ignore the data from the chunk demuxer.
+  // The data will be requested later when OnSeekRequestAck() is called.
+  if (pending_event_ & SEEK_EVENT_PENDING)
+    return;
+
   if (params.type == DemuxerStream::AUDIO) {
     DCHECK_EQ(0u, audio_access_unit_index_);
     received_audio_ = params;
-    waiting_for_audio_data_ = false;
-    DecodeMoreAudio();
+    if (!pending_event_)
+      DecodeMoreAudio();
   } else {
     DCHECK_EQ(0u, video_access_unit_index_);
     received_video_ = params;
-    waiting_for_video_data_ = false;
-    DecodeMoreVideo();
+    if (!pending_event_)
+      DecodeMoreVideo();
   }
 }
 
+void MediaSourcePlayer::OnSeekRequestAck() {
+  pending_event_ &= ~SEEK_EVENT_PENDING;
+  OnSeekComplete();
+  if (playing_)
+    StartInternal();
+}
+
 void MediaSourcePlayer::UpdateTimestamps(
-    const base::Time& kickoff_time,
     const base::TimeDelta& presentation_timestamp,
     const base::Time& wallclock_time) {
-  // If the job was posted after last seek, update the presentation time.
-  // Otherwise, ignore it.
-  if (kickoff_time > last_seek_time_) {
-    last_presentation_timestamp_ = presentation_timestamp;
-    OnTimeUpdated();
-    if (start_wallclock_time_.is_null() && playing_) {
-      start_wallclock_time_ = wallclock_time;
-      start_presentation_timestamp_ = last_presentation_timestamp_;
-    }
+  last_presentation_timestamp_ = presentation_timestamp;
+  OnTimeUpdated();
+  if (start_wallclock_time_.is_null() && playing_) {
+    start_wallclock_time_ = wallclock_time;
+    start_presentation_timestamp_ = last_presentation_timestamp_;
   }
 }
 
+void MediaSourcePlayer::ProcessPendingEvents() {
+  // Wait for all the decoding jobs to finish before sending a seek request.
+  if (active_decoding_tasks_ > 0)
+    return;
+
+  DCHECK(pending_event_ != NO_EVENT_PENDING);
+  if (use_empty_surface_ && (pending_event_ & SURFACE_CHANGE_EVENT_PENDING)) {
+    video_decoder_job_.reset();
+    pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING;
+  }
+
+  ClearDecodingData();
+  manager()->OnMediaSeekRequest(player_id(),
+                                last_presentation_timestamp_,
+                                pending_event_ & SURFACE_CHANGE_EVENT_PENDING);
+}
+
 void MediaSourcePlayer::MediaDecoderCallback(
-    bool is_audio, const base::Time& kickoff_time,
-    const base::TimeDelta& presentation_timestamp,
+    bool is_audio, const base::TimeDelta& presentation_timestamp,
     const base::Time& wallclock_time, bool end_of_stream) {
+  if (active_decoding_tasks_ > 0)
+    active_decoding_tasks_--;
+
+  if (pending_event_ != NO_EVENT_PENDING) {
+    ProcessPendingEvents();
+    return;
+  }
+
   if (is_audio || !HasAudio())
-    UpdateTimestamps(kickoff_time, presentation_timestamp, wallclock_time);
+    UpdateTimestamps(presentation_timestamp, wallclock_time);
 
   if (end_of_stream) {
     PlaybackCompleted(is_audio);
     return;
   }
 
   if (!playing_)
     return;
 
   if (is_audio)
@@ skipping 10 matching lines @@
       audio_access_unit_index_ = 0;
       waiting_for_audio_data_ = true;
     }
     return;
   }
 
   audio_decoder_job_->Decode(
       received_audio_.access_units[audio_access_unit_index_],
       start_wallclock_time_, start_presentation_timestamp_,
       base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
-                 weak_this_.GetWeakPtr(), true, base::Time::Now()));
-  ++audio_access_unit_index_;
+                 weak_this_.GetWeakPtr(), true));
+  active_decoding_tasks_++;
+  audio_access_unit_index_++;
 }
 
 void MediaSourcePlayer::DecodeMoreVideo() {
   if (video_access_unit_index_ >= received_video_.access_units.size()) {
     if (!waiting_for_video_data_) {
       manager()->OnReadFromDemuxer(player_id(), DemuxerStream::VIDEO, true);
       received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
       video_access_unit_index_ = 0;
       waiting_for_video_data_ = true;
     }
     return;
   }
 
   video_decoder_job_->Decode(
       received_video_.access_units[video_access_unit_index_],
       start_wallclock_time_, start_presentation_timestamp_,
       base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
-                 weak_this_.GetWeakPtr(), false, base::Time::Now()));
-  ++video_access_unit_index_;
+                 weak_this_.GetWeakPtr(), false));
+  active_decoding_tasks_++;
+  video_access_unit_index_++;
 }
 
 
 void MediaSourcePlayer::PlaybackCompleted(bool is_audio) {
   if (is_audio)
     audio_finished_ = true;
   else
     video_finished_ = true;
 
   if ((!HasAudio() || audio_finished_) && (!HasVideo() || video_finished_)) {
     playing_ = false;
     start_wallclock_time_ = base::Time();
     OnPlaybackComplete();
   }
 }
 
+void MediaSourcePlayer::ClearDecodingData() {
+  if (audio_decoder_job_)
+    audio_decoder_job_->Flush();
+  if (video_decoder_job_)
+    video_decoder_job_->Flush();
+  start_wallclock_time_ = base::Time();
+  received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+  received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
+  audio_access_unit_index_ = 0;
+  video_access_unit_index_ = 0;
+}
+
 bool MediaSourcePlayer::HasVideo() {
   return kUnknownVideoCodec != video_codec_;
 }
 
 bool MediaSourcePlayer::HasAudio() {
   return kUnknownAudioCodec != audio_codec_;
 }
 
 }  // namespace media