MediaCodecPlayer implementation (stage 4 - preroll)

media/base/android/media_codec_player_unittest.cc

 // Copyright 2015 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 "base/bind.h"
 #include "base/logging.h"
 #include "base/timer/timer.h"
 #include "media/base/android/demuxer_android.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_codec_player.h"
@@ skipping 219 matching lines @@
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   MockDemuxerAndroid()
       : client_(nullptr), num_seeks_(0), num_browser_seeks_(0) {}
   ~MockDemuxerAndroid() override {}
 
   // DemuxerAndroid implementation
   void Initialize(DemuxerAndroidClient* client) override;
   void RequestDemuxerData(DemuxerStream::Type type) override;
-  void RequestDemuxerSeek(const base::TimeDelta& time_to_seek,
+  void RequestDemuxerSeek(const base::TimeDelta& seek_request,
                           bool is_browser_seek) override;
 
   // Sets the audio data factory.
   void SetAudioFactory(scoped_ptr<AudioFactory> factory) {
     audio_factory_ = factory.Pass();
   }
 
   // Sets the video data factory.
   void SetVideoFactory(scoped_ptr<VideoFactory> factory) {
     video_factory_ = factory.Pass();
   }
 
+  // Set the preroll interval after seek for audio stream.
+  void SetAudioPrerollInterval(base::TimeDelta value) {
+    audio_preroll_interval_ = value;
+  }
+
+  // Set the preroll interval after seek for video stream.
+  void SetVideoPrerollInterval(base::TimeDelta value) {
+    video_preroll_interval_ = value;
+  }
+
   // Sets the delay in OnDemuxerSeekDone response.
   void SetSeekDoneDelay(base::TimeDelta delay) { seek_done_delay_ = delay; }
 
   // Post DemuxerConfigs to the client (i.e. the player) on correct thread.
   void PostConfigs(const DemuxerConfigs& configs);
 
   // Post DemuxerConfigs derived from data factories that has been set.
   void PostInternalConfigs();
 
   // Conditions to wait for.
   bool IsInitialized() const { return client_; }
   bool HasPendingConfigs() const { return pending_configs_; }
   bool ReceivedSeekRequest() const { return num_seeks_ > 0; }
   bool ReceivedBrowserSeekRequest() const { return num_browser_seeks_ > 0; }
 
  private:
   DemuxerAndroidClient* client_;
   scoped_ptr<DemuxerConfigs> pending_configs_;
   scoped_ptr<AudioFactory> audio_factory_;
   scoped_ptr<VideoFactory> video_factory_;
+  base::TimeDelta audio_preroll_interval_;
+  base::TimeDelta video_preroll_interval_;
   base::TimeDelta seek_done_delay_;
   int num_seeks_;
   int num_browser_seeks_;
 
   DISALLOW_COPY_AND_ASSIGN(MockDemuxerAndroid);
 };
 
 void MockDemuxerAndroid::Initialize(DemuxerAndroidClient* client) {
   DVLOG(1) << "MockDemuxerAndroid::" << __FUNCTION__;
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
@@ skipping 19 matching lines @@
   chunk.type = type;
 
   // Post to Media thread.
   DCHECK(client_);
   GetMediaTaskRunner()->PostDelayedTask(
       FROM_HERE, base::Bind(&DemuxerAndroidClient::OnDemuxerDataAvailable,
                             base::Unretained(client_), chunk),
       delay);
 }
 
-void MockDemuxerAndroid::RequestDemuxerSeek(const base::TimeDelta& time_to_seek,
+void MockDemuxerAndroid::RequestDemuxerSeek(const base::TimeDelta& seek_request,
                                             bool is_browser_seek) {
   // Tell data factories to start next chunk with the new timestamp.
-  if (audio_factory_)
+  if (audio_factory_) {
+    base::TimeDelta time_to_seek =
+        std::max(base::TimeDelta(), seek_request - audio_preroll_interval_);
     audio_factory_->SeekTo(time_to_seek);
+  }
   if (video_factory_) {
+    base::TimeDelta time_to_seek =
+        std::max(base::TimeDelta(), seek_request - video_preroll_interval_);
     video_factory_->SeekTo(time_to_seek);
     video_factory_->RequestKeyFrame();
   }
 
   ++num_seeks_;
   if (is_browser_seek)
     ++num_browser_seeks_;
 
   // Post OnDemuxerSeekDone() to the player.
   DCHECK(client_);
   base::TimeDelta reported_seek_time =
-      is_browser_seek ? time_to_seek : kNoTimestamp();
+      is_browser_seek ? seek_request : kNoTimestamp();
   GetMediaTaskRunner()->PostDelayedTask(
       FROM_HERE, base::Bind(&DemuxerAndroidClient::OnDemuxerSeekDone,
                             base::Unretained(client_), reported_seek_time),
       seek_done_delay_);
 }
 
 void MockDemuxerAndroid::PostConfigs(const DemuxerConfigs& configs) {
   RUN_ON_MEDIA_THREAD(MockDemuxerAndroid, PostConfigs, configs);
 
   DVLOG(1) << "MockDemuxerAndroid::" << __FUNCTION__;
@@ skipping 708 matching lines @@
                        reconfigure_timeout));
 
   // Timestamps should start at the new seek position
   EXPECT_LE(seek_position, manager_.pts_stat_.min());
 
   // The player should have reported the seek completion to the manager.
   EXPECT_TRUE(WaitForCondition(base::Bind(
       &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
+TEST_F(MediaCodecPlayerTest, VideoPrerollAfterSeek) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // A simple test for preroll for video stream only. After the seek is done
+  // the data factory generates the frames with pts before the seek time, and
+  // they should not be rendered. We deduce which frame is rendered by looking
+  // at the reported time progress.
+
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(600);
+  base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(500);
+  base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(800);
+
+  // Tell demuxer to make the first frame 100ms earlier than the seek request.
+  demuxer_->SetVideoPrerollInterval(base::TimeDelta::FromMilliseconds(100));
+
+  demuxer_->SetVideoFactory(
+      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+
+  CreatePlayer();
+  SetVideoSurface();
+
+  // Wait till the player is initialized on media thread.
+  EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
+                                          base::Unretained(demuxer_))));
+
+  // Post configuration after the player has been initialized.
+  demuxer_->PostInternalConfigs();
+
+  // Issue SeekTo().
+  player_->SeekTo(seek_position);
+
+  // Start the playback and make sure it is started.
+  player_->Start();
+
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
+                                  base::Unretained(&manager_)),
+                       start_timeout));
+
+  // Wait for completion.
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
+                                  base::Unretained(&manager_))));
+
+  // The first pts should be equal than seek position even if video frames
+  // started 100 ms eralier than the seek request.
+  EXPECT_EQ(seek_position, manager_.pts_stat_.min());
+
+  EXPECT_EQ(6, manager_.pts_stat_.num_values());
+}
+
 }  // namespace media