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_)

[ycheo (away), 2013/05/22 06:59:13]

This SeekTo() can be called from ContentVideoView::SeekTo() which is Java
thread.
So do we need a lock for the data members used in this method?

[qinmin, 2013/05/22 07:20:38]

SeekTo() is always called on the browser thread since the java view lives on it.
So there is no race condition here.
If you take a look at the MediaPlayerBridge, only the listener callbacks will be
on different threads. In that case, we always post the tasks onto the browser
thread.  Similarly for MediaSourcePlayer, all the calls should be on the browser
thread (excluding decoder jobs which has its own thread).

On 2013/05/22 06:59:13, Yuncheol Heo wrote:

+    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_ > 0)
+    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