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 175 matching lines @@
                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_media_seek_request_(false),
+      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),
@@ skipping 58 matching lines @@
   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_media_seek_request_ = true;
+  if (!active_decoding_tasks_)
+    manager()->OnMediaSeekRequest(player_id(), last_presentation_timestamp_);
 }
 
 base::TimeDelta MediaSourcePlayer::GetCurrentTime() {
   return last_presentation_timestamp_;
 }
 
 base::TimeDelta MediaSourcePlayer::GetDuration() {
   return duration_;
 }
 
 void MediaSourcePlayer::Release() {
   audio_decoder_job_.reset();
   video_decoder_job_.reset();
+  active_decoding_tasks_ = 0;
   ReleaseMediaResourcesFromManager();
 }
 
 void MediaSourcePlayer::SetVolume(float leftVolume, float rightVolume) {
 }
 
 bool MediaSourcePlayer::CanPause() {
   return seekable_;
 }
 
@@ skipping 34 matching lines @@
   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_media_seek_request_)
+    return;
+
   if (params.type == DemuxerStream::AUDIO) {
     DCHECK_EQ(0u, audio_access_unit_index_);
     received_audio_ = params;
-    waiting_for_audio_data_ = false;
     DecodeMoreAudio();
   } else {
     DCHECK_EQ(0u, video_access_unit_index_);
     received_video_ = params;
-    waiting_for_video_data_ = false;
     DecodeMoreVideo();
   }
 }
 
+void MediaSourcePlayer::OnSeekRequestAck() {
+  pending_media_seek_request_ = false;
+  OnSeekComplete();
+  if (!playing_)
+    return;
+
+  if (HasAudio())
+    DecodeMoreAudio();
+  if (HasVideo())
+    DecodeMoreVideo();
+}
+
 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::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_)

[acolwell GONE FROM CHROMIUM, 2013/05/21 17:49:42]

nit add '> 0' just to be safe or a DCHECK_GE(active_decoding_tasks_, 0)?

[qinmin, 2013/05/21 23:04:56]

Done.

+    active_decoding_tasks_--;
+
+  if (pending_media_seek_request_) {
+    // Wait for all the decoding jobs to finish before sending a seek request.
+    if (!active_decoding_tasks_) {
+      manager()->OnMediaSeekRequest(player_id(),
+                                    last_presentation_timestamp_);
+    }
+    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();
   }
 }
 
 bool MediaSourcePlayer::HasVideo() {
   return kUnknownVideoCodec != video_codec_;
 }
 
 bool MediaSourcePlayer::HasAudio() {
   return kUnknownAudioCodec != audio_codec_;
 }
 
 }  // namespace media