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 321 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 AudioTrack's buffer is full and the
+  // system starts to render the decoded audio.
+  void DecodeAudioDataUntilAudioBufferBecomesFull() {
+    EXPECT_TRUE(player_.IsPlaying());
+    int i = 0;
+    while (true) {

[wolenetz, 2014/04/15 20:40:22]

Is there a reasonable cap on number of decode iterations we should attempt
before giving up and failing here?

[qinmin, 2014/04/15 21:53:05]

It takes about 5-7 frames for the AudioTrack to start rendering frames. Putting
10 as a cap here.

On 2014/04/15 20:40:22, wolenetz wrote:

+      player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
+      WaitForAudioDecodeDone();
+      if (player_.GetCurrentTime().InMilliseconds() > 0)

[wolenetz, 2014/04/15 20:40:22]

I think a delta check not just > 0 here would be good. This would allow this
method to be used when initial time was already > 0.

[qinmin, 2014/04/15 21:53:05]

Done.

+        break;
+      if (i < 3)
+        ++i;
+    }
+  }
+
   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();
-  }
+  DecodeAudioDataUntilAudioBufferBecomesFull();
 
   // 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();
 
   // 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.
@@ skipping 363 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());
+  DecodeAudioDataUntilAudioBufferBecomesFull();
   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);
+  DecodeAudioDataUntilAudioBufferBecomesFull();
+  base::TimeDelta current_time = player_.GetCurrentTime();
+
+  // Trigger starvation while the decoder is decoding.
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
+  TriggerPlayerStarvation();
+  WaitForAudioDecodeDone();
+
+  // Current time should be updated.
+  EXPECT_LT(current_time.InMillisecondsF(),
+            player_.GetCurrentTime().InMillisecondsF());
+}
+
+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);
+
+  DecodeAudioDataUntilAudioBufferBecomesFull();
+  base::TimeDelta current_time = player_.GetCurrentTime();
+
+  DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(true, 0);
+  player_.OnDemuxerDataAvailable(data);
+  WaitForAudioDecodeDone();
+
+  // Simulate arrival of new configs.
+  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
+  for (int i = 0; i < 4; ++i) {
+    player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
+    WaitForAudioDecodeDone();
+    base::TimeDelta new_current_time = player_.GetCurrentTime();
+    EXPECT_LE(current_time.InMillisecondsF(),
+              new_current_time.InMillisecondsF());
+    current_time = new_current_time;
+  }
+}
+
 }  // namespace media