Fix Bug: Video with Variable Frame Rate plays at incorrect speed.

media/filters/video_renderer_algorithm_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 <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 1162 matching lines @@
       RunFramePumpTest(
           true, &frame_tg, &display_tg,
           [](const scoped_refptr<VideoFrame>& frame, size_t frames_dropped) {});
       if (HasFatalFailure())
         return;
     }
   }
 }
 
 // Rotate through various playback rates and ensure algorithm adapts correctly.
-TEST_F(VideoRendererAlgorithmTest, VariableFrameRateCadence) {
+TEST_F(VideoRendererAlgorithmTest, VariablePlaybackRateCadence) {
   TickGenerator frame_tg(base::TimeTicks(), NTSC(30));
   TickGenerator display_tg(tick_clock_->NowTicks(), 60);
 
   const double kTestRates[] = {1.0, 2, 0.215, 0.5, 1.0, 3.15};
   const bool kTestRateHasCadence[arraysize(kTestRates)] = {true, true, true,
                                                            true, true, false};
 
   for (size_t i = 0; i < arraysize(kTestRates); ++i) {
     const double playback_rate = kTestRates[i];
     SCOPED_TRACE(base::StringPrintf("Playback Rate: %.03f", playback_rate));
@@ skipping 40 matching lines @@
     // enough frames are encountered; after which it should not drop out of
     // cadence.
     if (is_using_cadence())
       cadence_detected = true;
 
     if (cadence_detected)
       ASSERT_TRUE(is_using_cadence());
   }
 }
 
+// Ensures media with variable frame rate should not be applied with Cadence.
+TEST_F(VideoRendererAlgorithmTest, VariableFrameRateNoCadence) {
+  TickGenerator display_tg(tick_clock_->NowTicks(), 60);
+  time_source_.StartTicking();
+
+  const int kBadTimestampsMs[] = {200,  200,  200,  200,  200,  1000,
+                                  1000, 1000, 1000, 200,  200,  200,
+                                  200,  200,  1000, 1000, 1000, 1000};
+
+  // Run throught ~10 seconds worth of frames.
+  bool cadence_detected = false;
+  bool cadence_turned_off = false;
+  base::TimeDelta timestamp;
+  for (size_t i = 0; i < arraysize(kBadTimestampsMs);) {
+    while (algorithm_.EffectiveFramesQueued() < 3) {
+      algorithm_.EnqueueFrame(CreateFrame(timestamp));
+      timestamp += base::TimeDelta::FromMilliseconds(
+          kBadTimestampsMs[i % arraysize(kBadTimestampsMs)]);
+      ++i;
+    }
+
+    size_t frames_dropped = 0;
+    RenderAndStep(&display_tg, &frames_dropped);
+    ASSERT_EQ(0u, frames_dropped);
+
+    // Cadence would be detected during the first second, and then
+    // it should be off due to variable FPS detection, and then for this
+    // sample, it should never be on.
+    if (is_using_cadence())
+      cadence_detected = true;
+
+    if (cadence_detected) {
+      if (!is_using_cadence())
+        cadence_turned_off = true;
+    }
+
+    if (cadence_turned_off) {
+      ASSERT_FALSE(is_using_cadence());
+    }
+  }
+
+  // Make sure Cadence is turned off somewhen, not always on.
+  ASSERT_TRUE(cadence_turned_off);
+}
+
 TEST_F(VideoRendererAlgorithmTest, EnqueueFrames) {
   TickGenerator tg(base::TimeTicks(), 50);
   time_source_.StartTicking();
 
   EXPECT_EQ(0u, frames_queued());
   scoped_refptr<VideoFrame> frame_1 = CreateFrame(tg.interval(0));
   algorithm_.EnqueueFrame(frame_1);
   EXPECT_EQ(1u, frames_queued());
 
   // Enqueuing a frame with the same timestamp should always be dropped.
@@ skipping 84 matching lines @@
   ASSERT_TRUE(is_using_cadence());
 
   // Finally the last frame.
   rendered_frame = RenderAndStep(&tg, &frames_dropped);
   EXPECT_EQ(1u, frames_queued());
   EXPECT_EQ(tg.interval(12), rendered_frame->timestamp());
   ASSERT_TRUE(is_using_cadence());
 }
 
 }  // namespace media