Fix an issue that audio and video may ran out of sync

media/base/android/media_source_player_unittest.cc

 // Copyright 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 <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 23 matching lines @@
 // TODO(wolenetz/qinmin): Simplify tests with more effective mock usage, and
 // fix flaky pointer-based MDJ inequality testing. See http://crbug.com/327839.
 
 // Mock of MediaPlayerManager for testing purpose.
 class MockMediaPlayerManager : public MediaPlayerManager {
  public:
   explicit MockMediaPlayerManager(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
         playback_completed_(false),
         num_resources_requested_(0),
-        num_resources_released_(0) {}
+        num_resources_released_(0),
+        timestamp_updated_(false) {}
   virtual ~MockMediaPlayerManager() {}
 
   // MediaPlayerManager implementation.
   virtual MediaResourceGetter* GetMediaResourceGetter() OVERRIDE {
     return NULL;
   }
   virtual void OnTimeUpdate(int player_id,
-                            base::TimeDelta current_time) OVERRIDE {}
+                            base::TimeDelta current_time) OVERRIDE {
+    timestamp_updated_ = true;
+  }
   virtual void OnMediaMetadataChanged(
       int player_id, base::TimeDelta duration, int width, int height,
       bool success) OVERRIDE {}
   virtual void OnPlaybackComplete(int player_id) OVERRIDE {
     playback_completed_ = true;
     if (message_loop_->is_running())
       message_loop_->Quit();
   }
   virtual void OnMediaInterrupted(int player_id) OVERRIDE {}
   virtual void OnBufferingUpdate(int player_id, int percentage) OVERRIDE {}
@@ skipping 34 matching lines @@
   }
 
   void OnMediaResourcesRequested(int player_id) {
     num_resources_requested_++;
   }
 
   void OnMediaResourcesReleased(int player_id) {
     num_resources_released_++;
   }
 
+  bool timestamp_updated() const {
+    return timestamp_updated_;
+  }
+
+  void ResetTimestampUpdated() {
+    timestamp_updated_ = false;
+  }
+
  private:
   base::MessageLoop* message_loop_;
   bool playback_completed_;
   // The number of resource requests this object has seen.
   int num_resources_requested_;
   // The number of released resources.
   int num_resources_released_;
+  // Playback timestamp was updated.
+  bool timestamp_updated_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
         num_data_requests_(0),
         num_seek_requests_(0),
@@ skipping 208 matching lines @@
               demuxer_->num_data_requests());
 
     // Verify player has decoder job iff the config included the media type for
     // the job and the player is expected to request data due to Start(), above.
     EXPECT_EQ(expect_player_requests_data && has_audio,
               GetMediaDecoderJob(true) != NULL);
     EXPECT_EQ(expect_player_requests_data && has_video,
               GetMediaDecoderJob(false) != NULL);
   }
 
+  // Keeps decoding audio data until the decoder starts to output samples.
+  // Gives up if no audio output after decoding 10 frames.
+  void DecodeAudioDataUntilOutputBecomesAvailable() {
+    EXPECT_TRUE(player_.IsPlaying());
+    base::TimeDelta current_time = player_.GetCurrentTime();
+    for (int i = 0; i < 10; ++i) {
+      manager_.ResetTimestampUpdated();
+      player_.OnDemuxerDataAvailable(
+          CreateReadFromDemuxerAckForAudio(i > 3 ? 3 : i));
+      WaitForAudioDecodeDone();
+      base::TimeDelta new_current_time = player_.GetCurrentTime();
+      EXPECT_LE(current_time.InMilliseconds(),
+                new_current_time.InMilliseconds());
+      current_time = new_current_time;
+      if (manager_.timestamp_updated())

[wolenetz, 2014/04/17 21:35:28]

Please also include the time delta check here. Only consider audio frames output
iff both the timestamp was updated AND new_current_time > old current time.
IIUC, the latter was previously insufficient because the clock could advance a
little even if MSP::updatetimestamp wasn't called (due to just test delays on
slower devices while waiting for successful decode with some output). But the
latter is still a requirement.

[qinmin, 2014/04/17 23:03:35]

Done.

+        return;
+    }
+    EXPECT_TRUE(false);
+  }
+
   AccessUnit CreateAccessUnitWithData(bool is_audio, int audio_packet_id) {
     AccessUnit unit;
 
     unit.status = DemuxerStream::kOk;
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(
         is_audio ? base::StringPrintf("vorbis-packet-%d", audio_packet_id)
             : "vp8-I-frame-320x240");
     unit.data = std::vector<uint8>(
         buffer->data(), buffer->data() + buffer->data_size());
 
@@ skipping 718 matching lines @@
   // No seeks should have occurred.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartTimeTicksResetAfterDecoderUnderruns) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test start time ticks will reset after decoder job underruns.
   StartAudioDecoderJob(true);
 
-  // For the first couple chunks, the decoder job may return
-  // DECODE_FORMAT_CHANGED status instead of DECODE_SUCCEEDED status. Decode
-  // more frames to guarantee that DECODE_SUCCEEDED will be returned.
-  for (int i = 0; i < 4; ++i) {
-    player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
-    EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
-    // Decode data until decoder started requesting new data again.
-    WaitForAudioDecodeDone();
-  }
+  DecodeAudioDataUntilOutputBecomesAvailable();
 
   // The decoder job should finish and a new request will be sent.
-  EXPECT_EQ(5, demuxer_->num_data_requests());
-  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   base::TimeTicks previous = StartTimeTicks();
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
 
   // Let the decoder starve.
   TriggerPlayerStarvation();
-  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
   WaitForAudioDecodeDone();
 
   // Verify the start time ticks is cleared at this point because the
   // player is prefetching.
   EXPECT_TRUE(StartTimeTicks() == base::TimeTicks());
 
   // Send new data to the decoder so it can finish prefetching. This should
   // reset the start time ticks.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
   EXPECT_TRUE(StartTimeTicks() != base::TimeTicks());
@@ skipping 357 matching lines @@
 TEST_F(MediaSourcePlayerTest, SeekingAfterCompletingPrerollRestartsPreroll) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will begin prerolling upon seek, when it was not
   // prerolling prior to the seek.
   StartAudioDecoderJob(true);
   MediaDecoderJob* decoder_job = GetMediaDecoderJob(true);
   EXPECT_TRUE(IsPrerolling(true));
 
   // Complete the initial preroll by feeding data to the decoder.
-  for (int i = 0; i < 4; ++i) {
-    player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
-    EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
-    WaitForAudioDecodeDone();
-  }
-  EXPECT_LT(0.0, player_.GetCurrentTime().InMillisecondsF());
+  DecodeAudioDataUntilOutputBecomesAvailable();
   EXPECT_FALSE(IsPrerolling(true));
 
   SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(500));
 
   // Prerolling should have begun again.
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(500.0, GetPrerollTimestamp().InMillisecondsF());
 
   // Send data at and after the seek position. Prerolling should complete.
   for (int i = 0; i < 4; ++i) {
@@ skipping 569 matching lines @@
   // player has not yet received media crypto.
   DemuxerConfigs configs = CreateVideoDemuxerConfigs();
   configs.is_video_encrypted = true;
 
   player_.OnDemuxerConfigsAvailable(configs);
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(IsPendingSurfaceChange());
   EXPECT_FALSE(GetMediaDecoderJob(false));
 }
 
+TEST_F(MediaSourcePlayerTest, CurrentTimeUpdatedWhileDecoderStarved) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that current time is updated while decoder is starved.
+  StartAudioDecoderJob(true);
+  DecodeAudioDataUntilOutputBecomesAvailable();
+
+  // Trigger starvation while the decoder is decoding.
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
+  manager_.ResetTimestampUpdated();
+  TriggerPlayerStarvation();
+  WaitForAudioDecodeDone();
+
+  // Current time should be updated.
+  EXPECT_TRUE(manager_.timestamp_updated());
+}
+
+TEST_F(MediaSourcePlayerTest, CurrentTimeKeepsIncreasingAfterConfigChange) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test current time keep on increasing after audio config change.
+  // Test that current time is updated while decoder is starved.
+  StartAudioDecoderJob(true);
+
+  DecodeAudioDataUntilOutputBecomesAvailable();
+
+  DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(true, 0);
+  player_.OnDemuxerDataAvailable(data);
+  WaitForAudioDecodeDone();
+
+  // Simulate arrival of new configs.
+  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
+  DecodeAudioDataUntilOutputBecomesAvailable();
+}
+
 }  // namespace media