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) {
-  OnMediaMetadataChanged(duration_, width_, height_, false);
 }
 
 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;
   }
 
   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 performed a seek in this case.
+    pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING;

[acolwell GONE FROM CHROMIUM, 2013/05/23 20:58:27]

nit: DCHECK_EQ(pending_event_ & SEEK_EVENT_PENDING, 0)?

[qinmin, 2013/05/23 22:03:36]

We cannot guarantee the bit is cleared at this time. Here is what can happen:
Browser send the SeekRequest msg to renderer.
Renderer sends back the SeekRequestAck, and sends an IPC to gpu thread to pass
the surface to the player. 
The gpu thead might get the IPC first, and post a task onto the browser thread
to call this function. In that case, the SEEK_EVENT_PENDING flag is still not
cleared yet.

Changed the description though. change "performed" to "requested"

On 2013/05/23 20:58:27, acolwell wrote:

+  } 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