MediaCodecPlayer implementation (stage 5 - reconfiguration)

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 44 matching lines @@
   return (a - b).magnitude().InMilliseconds() <= tolerance_ms;
 }
 
 // Mock of MediaPlayerManager for testing purpose.
 
 class MockMediaPlayerManager : public MediaPlayerManager {
  public:
   MockMediaPlayerManager()
       : playback_completed_(false),
         num_seeks_completed_(0),
+        num_video_codec_created_(0),
         weak_ptr_factory_(this) {}
   ~MockMediaPlayerManager() override {}
 
   MediaResourceGetter* GetMediaResourceGetter() override { return nullptr; }
   MediaUrlInterceptor* GetMediaUrlInterceptor() override { return nullptr; }
 
   // Regular time update callback, reports current playback time to
   // MediaPlayerManager.
   void OnTimeUpdate(int player_id,
                     base::TimeDelta current_timestamp,
@@ skipping 23 matching lines @@
     ++num_seeks_completed_;
   }
   void OnError(int player_id, int error) override {}
   void OnVideoSizeChanged(int player_id, int width, int height) override {}
   void OnAudibleStateChanged(int player_id, bool is_audible_now) override {}
   void OnWaitingForDecryptionKey(int player_id) override {}
   MediaPlayerAndroid* GetFullscreenPlayer() override { return nullptr; }
   MediaPlayerAndroid* GetPlayer(int player_id) override { return nullptr; }
   bool RequestPlay(int player_id) override { return true; }
 
-  void OnMediaResourcesRequested(int player_id) {}
+  void OnMediaResourcesRequested(int player_id) { ++num_video_codec_created_; }
 
   // Time update callback that reports the internal progress of the stream.
   // Implementation dependent, used for testing only.
   void OnDecodersTimeUpdate(DemuxerStream::Type stream_type,
                             base::TimeDelta now_playing,
                             base::TimeDelta last_buffered) {
-    PTSTime& hit = first_frame_hit_[stream_type];
-    if (hit.is_null())
-      hit = PTSTime(now_playing, base::TimeTicks::Now());
+    render_stat_[stream_type].AddValue(
+        PTSTime(now_playing, base::TimeTicks::Now()));
   }
 
   // First frame information
   base::TimeDelta FirstFramePTS(DemuxerStream::Type stream_type) const {
-    return first_frame_hit_[stream_type].pts;
+    return render_stat_[stream_type].min().pts;
   }
   base::TimeTicks FirstFrameTime(DemuxerStream::Type stream_type) const {
-    return first_frame_hit_[stream_type].time;
+    return render_stat_[stream_type].min().time;
   }
 
   base::WeakPtr<MockMediaPlayerManager> GetWeakPtr() {
     return weak_ptr_factory_.GetWeakPtr();
   }
 
   // Conditions to wait for.
   bool IsMetadataChanged() const { return media_metadata_.modified; }
   bool IsPlaybackCompleted() const { return playback_completed_; }
   bool IsPlaybackStarted() const { return pts_stat_.num_values() > 0; }
   bool IsPlaybackBeyondPosition(const base::TimeDelta& pts) const {
     return pts_stat_.max() > pts;
   }
   bool IsSeekCompleted() const { return num_seeks_completed_ > 0; }
   bool HasFirstFrame(DemuxerStream::Type stream_type) const {
-    return !first_frame_hit_[stream_type].is_null();
+    return render_stat_[stream_type].num_values() != 0;
   }
 
+  int num_video_codec_created() const { return num_video_codec_created_; }
+
   struct MediaMetadata {
     base::TimeDelta duration;
     int width;
     int height;
     bool modified;
     MediaMetadata() : width(0), height(0), modified(false) {}
   };
   MediaMetadata media_metadata_;
 
+  struct PTSTime {
+    base::TimeDelta pts;
+    base::TimeTicks time;
+
+    PTSTime() : pts(), time() {}
+    PTSTime(base::TimeDelta p, base::TimeTicks t) : pts(p), time(t) {}
+    bool is_null() const { return time.is_null(); }
+    bool operator<(const PTSTime& rhs) const { return time < rhs.time; }
+  };
+  Minimax<PTSTime> render_stat_[DemuxerStream::NUM_TYPES];
+
   Minimax<base::TimeDelta> pts_stat_;
 
  private:
   bool playback_completed_;
   int num_seeks_completed_;
-
-  struct PTSTime {
-    base::TimeDelta pts;
-    base::TimeTicks time;
-    PTSTime() : pts(), time() {}
-    PTSTime(base::TimeDelta p, base::TimeTicks t) : pts(p), time(t) {}
-    bool is_null() const { return time.is_null(); }
-  };
-  PTSTime first_frame_hit_[DemuxerStream::NUM_TYPES];
+  int num_video_codec_created_;
 
   base::WeakPtrFactory<MockMediaPlayerManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 // Helper method that creates demuxer configuration.
 
 DemuxerConfigs CreateAudioVideoConfigs(const base::TimeDelta& duration,
                                        const gfx::Size& video_size) {
@@ skipping 198 matching lines @@
 
   bool created = false;
   if (type == DemuxerStream::AUDIO && audio_factory_)
     created = audio_factory_->CreateChunk(&chunk, &delay);
   else if (type == DemuxerStream::VIDEO && video_factory_)
     created = video_factory_->CreateChunk(&chunk, &delay);
 
   if (!created)
     return;
 
+  // Request key frame after |kConfigChanged|
+  if (type == DemuxerStream::VIDEO && !chunk.demuxer_configs.empty())
+    video_factory_->RequestKeyFrame();
+
   chunk.type = type;
 
   // Post to the Media thread. Use the weak pointer to prevent the data arrival
   // after the player has been deleted.
   GetMediaTaskRunner()->PostDelayedTask(
       FROM_HERE, base::Bind(&MockDemuxerAndroid::OnDemuxerDataAvailable,
                             weak_factory_.GetWeakPtr(), chunk),
       delay);
 }
 
@@ skipping 443 matching lines @@
   // Wait till completion.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        timeout));
 
   EXPECT_LE(duration, manager_.pts_stat_.max());
 }
 
 // http://crbug.com/518900
-TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekAfterStop) {
+TEST_F(MediaCodecPlayerTest, AudioSeekAfterStop) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Play for 300 ms, then Pause, then Seek to beginning. The playback should
   // start from the beginning.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
 
   demuxer_->SetAudioFactory(
       scoped_ptr<AudioFactory>(new AudioFactory(duration)));
 
@@ skipping 112 matching lines @@
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 1));
 
   // The player should have reported the seek completion to the manager.
   EXPECT_TRUE(WaitForCondition(base::Bind(
       &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
 // http://crbug.com/518900
-TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekWhilePlaying) {
+TEST_F(MediaCodecPlayerTest, AudioSeekWhilePlaying) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Play for 300 ms, then issue several Seek commands in the row.
   // The playback should continue at the last seek position.
 
   // To test this condition without analyzing the reported time details
   // and without introducing dependency on implementation I make a long (10s)
   // duration and test that the playback resumes after big time jump (5s) in a
   // short period of time (200 ms).
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
@@ skipping 108 matching lines @@
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        reconfigure_timeout));
 
   // Timestamps should not go back.
   EXPECT_LE(max_pts_before_removal, manager_.pts_stat_.max());
 }
 
 // http://crbug.com/518900
-TEST_F(MediaCodecPlayerTest, DISABLED_VideoReleaseAndStart) {
+TEST_F(MediaCodecPlayerTest, VideoReleaseAndStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
 
   ASSERT_TRUE(StartVideoPlayback(duration, "VideoReleaseAndStart"));
 
   // Wait for some time and check statistics.
   WaitForDelay(base::TimeDelta::FromMilliseconds(200));
 
   // Make sure we played at least 100 ms.
@@ skipping 458 matching lines @@
 
   // Play till completion.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_))));
 
   // There should not be any video frames.
   EXPECT_FALSE(manager_.HasFirstFrame(DemuxerStream::VIDEO));
 }
 
+TEST_F(MediaCodecPlayerTest, AVConfigChangeWhilePlaying) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that playback continues after video config change.
+
+  // Initialize A/V playback
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(800);
+  base::TimeDelta config_change_position =
+      base::TimeDelta::FromMilliseconds(400);
+
+  base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(2000);
+
+  demuxer_->SetAudioFactory(
+      scoped_ptr<AudioFactory>(new AudioFactory(duration)));
+  demuxer_->SetVideoFactory(
+      scoped_ptr<VideoFactory>(new VideoFactory(duration)));
+
+  demuxer_->video_factory()->RequestConfigChange(config_change_position);
+
+  CreatePlayer();
+  SetVideoSurface();
+
+  // Set special testing callback to receive PTS from decoders.
+  player_->SetDecodersTimeCallbackForTests(
+      base::Bind(&MockMediaPlayerManager::OnDecodersTimeUpdate,
+                 base::Unretained(&manager_)));
+
+  // Wait till the player is initialized on media thread.
+  EXPECT_TRUE(WaitForCondition(base::Bind(&MockDemuxerAndroid::IsInitialized,
+                                          base::Unretained(demuxer_))));
+
+  if (!demuxer_->IsInitialized()) {
+    DVLOG(0) << "AVConfigChangeWhilePlaying: demuxer is not initialized";
+    return;
+  }
+
+  // Ask decoders to always reconfigure after the player has been initialized.
+  player_->SetAlwaysReconfigureForTests(DemuxerStream::VIDEO);
+
+  // Post configuration after the player has been initialized.
+  demuxer_->PostInternalConfigs();
+
+  // Start and wait for playback.
+  player_->Start();
+
+  // Wait till we start to play.
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
+                                  base::Unretained(&manager_)),
+                       start_timeout));
+
+  // Wait another 100 ms to make sure we are done with initial preroll.
+  WaitForDelay(base::TimeDelta::FromMilliseconds(100));
+
+  EXPECT_FALSE(player_->IsPrerollingForTests(DemuxerStream::AUDIO));
+  EXPECT_FALSE(player_->IsPrerollingForTests(DemuxerStream::VIDEO));
+
+  // Wait till completion
+  EXPECT_TRUE(
+      WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
+                                  base::Unretained(&manager_)),
+                       base::TimeDelta::FromMilliseconds(2000)));
+
+  // The video codec should be recreated upon config changes.
+  EXPECT_EQ(2, manager_.num_video_codec_created());
+
+  // Check that we did not miss video frames
+  EXPECT_EQ(41, manager_.render_stat_[DemuxerStream::VIDEO].num_values());
+}
+
 }  // namespace media