| // Copyright (c) 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 "media/capture/content/smooth_event_sampler.h" |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include "base/macros.h" |
| #include "base/strings/stringprintf.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace media { |
| |
| namespace { |
| |
| bool AddEventAndConsiderSampling(SmoothEventSampler* sampler, |
| base::TimeTicks event_time) { |
| sampler->ConsiderPresentationEvent(event_time); |
| return sampler->ShouldSample(); |
| } |
| |
| void SteadyStateSampleAndAdvance(base::TimeDelta vsync, |
| SmoothEventSampler* sampler, |
| base::TimeTicks* t) { |
| ASSERT_TRUE(AddEventAndConsiderSampling(sampler, *t)); |
| ASSERT_TRUE(sampler->HasUnrecordedEvent()); |
| sampler->RecordSample(); |
| ASSERT_FALSE(sampler->HasUnrecordedEvent()); |
| ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t)); |
| *t += vsync; |
| ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t)); |
| } |
| |
| void SteadyStateNoSampleAndAdvance(base::TimeDelta vsync, |
| SmoothEventSampler* sampler, |
| base::TimeTicks* t) { |
| ASSERT_FALSE(AddEventAndConsiderSampling(sampler, *t)); |
| ASSERT_TRUE(sampler->HasUnrecordedEvent()); |
| ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t)); |
| *t += vsync; |
| ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t)); |
| } |
| |
| base::TimeTicks InitialTestTimeTicks() { |
| return base::TimeTicks() + base::TimeDelta::FromSeconds(1); |
| } |
| |
| void TestRedundantCaptureStrategy(base::TimeDelta capture_period, |
| int redundant_capture_goal, |
| SmoothEventSampler* sampler, |
| base::TimeTicks* t) { |
| // Before any events have been considered, we're overdue for sampling. |
| ASSERT_TRUE(sampler->IsOverdueForSamplingAt(*t)); |
| |
| // Consider the first event. We want to sample that. |
| ASSERT_FALSE(sampler->HasUnrecordedEvent()); |
| ASSERT_TRUE(AddEventAndConsiderSampling(sampler, *t)); |
| ASSERT_TRUE(sampler->HasUnrecordedEvent()); |
| sampler->RecordSample(); |
| ASSERT_FALSE(sampler->HasUnrecordedEvent()); |
| |
| // After more than 250 ms has passed without considering an event, we should |
| // repeatedly be overdue for sampling. However, once the redundant capture |
| // goal is achieved, we should no longer be overdue for sampling. |
| *t += base::TimeDelta::FromMilliseconds(250); |
| for (int i = 0; i < redundant_capture_goal; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| ASSERT_FALSE(sampler->HasUnrecordedEvent()); |
| ASSERT_TRUE(sampler->IsOverdueForSamplingAt(*t)) |
| << "Should sample until redundant capture goal is hit"; |
| sampler->RecordSample(); |
| *t += capture_period; // Timer fires once every capture period. |
| } |
| ASSERT_FALSE(sampler->IsOverdueForSamplingAt(*t)) |
| << "Should not be overdue once redundant capture goal achieved."; |
| } |
| |
| } // namespace |
| |
| // 60Hz sampled at 30Hz should produce 30Hz. In addition, this test contains |
| // much more comprehensive before/after/edge-case scenarios than the others. |
| TEST(SmoothEventSamplerTest, Sample60HertzAt30Hertz) { |
| const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30; |
| const int redundant_capture_goal = 200; |
| const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 60; |
| |
| SmoothEventSampler sampler(capture_period, redundant_capture_goal); |
| base::TimeTicks t = InitialTestTimeTicks(); |
| |
| TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler, |
| &t); |
| |
| // Steady state, we should capture every other vsync, indefinitely. |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now pretend we're limited by backpressure in the pipeline. In this scenario |
| // case we are adding events but not sampling them. |
| for (int i = 0; i < 20; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| ASSERT_EQ(i >= 14, sampler.IsOverdueForSamplingAt(t)); |
| ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t)); |
| ASSERT_TRUE(sampler.HasUnrecordedEvent()); |
| t += vsync; |
| } |
| |
| // Now suppose we can sample again. We should be back in the steady state, |
| // but at a different phase. |
| ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t)); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| } |
| } |
| |
| // 50Hz sampled at 30Hz should produce a sequence where some frames are skipped. |
| TEST(SmoothEventSamplerTest, Sample50HertzAt30Hertz) { |
| const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30; |
| const int redundant_capture_goal = 2; |
| const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 50; |
| |
| SmoothEventSampler sampler(capture_period, redundant_capture_goal); |
| base::TimeTicks t = InitialTestTimeTicks(); |
| |
| TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler, |
| &t); |
| |
| // Steady state, we should capture 1st, 2nd and 4th frames out of every five |
| // frames, indefinitely. |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now pretend we're limited by backpressure in the pipeline. In this scenario |
| // case we are adding events but not sampling them. |
| for (int i = 0; i < 20; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| ASSERT_EQ(i >= 11, sampler.IsOverdueForSamplingAt(t)); |
| ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t)); |
| t += vsync; |
| } |
| |
| // Now suppose we can sample again. We should be back in the steady state |
| // again. |
| ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t)); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| } |
| } |
| |
| // 75Hz sampled at 30Hz should produce a sequence where some frames are skipped. |
| TEST(SmoothEventSamplerTest, Sample75HertzAt30Hertz) { |
| const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30; |
| const int redundant_capture_goal = 32; |
| const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 75; |
| |
| SmoothEventSampler sampler(capture_period, redundant_capture_goal); |
| base::TimeTicks t = InitialTestTimeTicks(); |
| |
| TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler, |
| &t); |
| |
| // Steady state, we should capture 1st and 3rd frames out of every five |
| // frames, indefinitely. |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now pretend we're limited by backpressure in the pipeline. In this scenario |
| // case we are adding events but not sampling them. |
| for (int i = 0; i < 20; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| ASSERT_EQ(i >= 16, sampler.IsOverdueForSamplingAt(t)); |
| ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t)); |
| t += vsync; |
| } |
| |
| // Now suppose we can sample again. We capture the next frame, and not the one |
| // after that, and then we're back in the steady state again. |
| ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| } |
| } |
| |
| // 30Hz sampled at 30Hz should produce 30Hz. |
| TEST(SmoothEventSamplerTest, Sample30HertzAt30Hertz) { |
| const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30; |
| const int redundant_capture_goal = 1; |
| const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 30; |
| |
| SmoothEventSampler sampler(capture_period, redundant_capture_goal); |
| base::TimeTicks t = InitialTestTimeTicks(); |
| |
| TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler, |
| &t); |
| |
| // Steady state, we should capture every vsync, indefinitely. |
| for (int i = 0; i < 200; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now pretend we're limited by backpressure in the pipeline. In this scenario |
| // case we are adding events but not sampling them. |
| for (int i = 0; i < 10; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| ASSERT_EQ(i >= 7, sampler.IsOverdueForSamplingAt(t)); |
| ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t)); |
| t += vsync; |
| } |
| |
| // Now suppose we can sample again. We should be back in the steady state. |
| ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t)); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| } |
| |
| // 24Hz sampled at 30Hz should produce 24Hz. |
| TEST(SmoothEventSamplerTest, Sample24HertzAt30Hertz) { |
| const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30; |
| const int redundant_capture_goal = 333; |
| const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 24; |
| |
| SmoothEventSampler sampler(capture_period, redundant_capture_goal); |
| base::TimeTicks t = InitialTestTimeTicks(); |
| |
| TestRedundantCaptureStrategy(capture_period, redundant_capture_goal, &sampler, |
| &t); |
| |
| // Steady state, we should capture every vsync, indefinitely. |
| for (int i = 0; i < 200; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now pretend we're limited by backpressure in the pipeline. In this scenario |
| // case we are adding events but not sampling them. |
| for (int i = 0; i < 10; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| ASSERT_EQ(i >= 6, sampler.IsOverdueForSamplingAt(t)); |
| ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t)); |
| t += vsync; |
| } |
| |
| // Now suppose we can sample again. We should be back in the steady state. |
| ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t)); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| } |
| |
| // Tests that changing the minimum capture period during usage results in the |
| // desired behavior. |
| TEST(SmoothEventSamplerTest, Sample60HertzWithVariedCapturePeriods) { |
| const base::TimeDelta vsync = base::TimeDelta::FromSeconds(1) / 60; |
| const base::TimeDelta one_to_one_period = vsync; |
| const base::TimeDelta two_to_one_period = vsync * 2; |
| const base::TimeDelta two_and_three_to_one_period = |
| base::TimeDelta::FromSeconds(1) / 24; |
| const int redundant_capture_goal = 1; |
| |
| SmoothEventSampler sampler(one_to_one_period, redundant_capture_goal); |
| base::TimeTicks t = InitialTestTimeTicks(); |
| |
| TestRedundantCaptureStrategy(one_to_one_period, redundant_capture_goal, |
| &sampler, &t); |
| |
| // With the capture rate at 60 Hz, we should capture every vsync. |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now change to the capture rate to 30 Hz, and we should capture every other |
| // vsync. |
| sampler.SetMinCapturePeriod(two_to_one_period); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now change the capture rate back to 60 Hz, and we should capture every |
| // vsync again. |
| sampler.SetMinCapturePeriod(one_to_one_period); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| |
| // Now change the capture rate to 24 Hz, and we should capture with a 2-3-2-3 |
| // cadence. |
| sampler.SetMinCapturePeriod(two_and_three_to_one_period); |
| for (int i = 0; i < 100; i++) { |
| SCOPED_TRACE(base::StringPrintf("Iteration %d", i)); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateNoSampleAndAdvance(vsync, &sampler, &t); |
| SteadyStateSampleAndAdvance(vsync, &sampler, &t); |
| } |
| } |
| |
| TEST(SmoothEventSamplerTest, DoubleDrawAtOneTimeStillDirties) { |
| const base::TimeDelta capture_period = base::TimeDelta::FromSeconds(1) / 30; |
| const base::TimeDelta overdue_period = base::TimeDelta::FromSeconds(1); |
| |
| SmoothEventSampler sampler(capture_period, 1); |
| base::TimeTicks t = InitialTestTimeTicks(); |
| |
| ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t)); |
| sampler.RecordSample(); |
| ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t)) |
| << "Sampled last event; should not be dirty."; |
| t += overdue_period; |
| |
| // Now simulate 2 events with the same clock value. |
| ASSERT_TRUE(AddEventAndConsiderSampling(&sampler, t)); |
| sampler.RecordSample(); |
| ASSERT_FALSE(AddEventAndConsiderSampling(&sampler, t)) |
| << "Two events at same time -- expected second not to be sampled."; |
| ASSERT_TRUE(sampler.IsOverdueForSamplingAt(t + overdue_period)) |
| << "Second event should dirty the capture state."; |
| sampler.RecordSample(); |
| ASSERT_FALSE(sampler.IsOverdueForSamplingAt(t + overdue_period)); |
| } |
| |
| namespace { |
| |
| struct DataPoint { |
| bool should_capture; |
| double increment_ms; |
| }; |
| |
| void ReplayCheckingSamplerDecisions(const DataPoint* data_points, |
| size_t num_data_points, |
| SmoothEventSampler* sampler) { |
| base::TimeTicks t = InitialTestTimeTicks(); |
| for (size_t i = 0; i < num_data_points; ++i) { |
| t += base::TimeDelta::FromMicroseconds( |
| static_cast<int64_t>(data_points[i].increment_ms * 1000)); |
| ASSERT_EQ(data_points[i].should_capture, |
| AddEventAndConsiderSampling(sampler, t)) |
| << "at data_points[" << i << ']'; |
| if (data_points[i].should_capture) |
| sampler->RecordSample(); |
| } |
| } |
| |
| } // namespace |
| |
| TEST(SmoothEventSamplerTest, DrawingAt24FpsWith60HzVsyncSampledAt30Hertz) { |
| // Actual capturing of timing data: Initial instability as a 24 FPS video was |
| // started from a still screen, then clearly followed by steady-state. |
| static const DataPoint data_points[] = {{true, 1437.93}, |
| {true, 150.484}, |
| {true, 217.362}, |
| {true, 50.161}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 16.721}, |
| {true, 66.88}, |
| {true, 50.161}, |
| {false, 0}, |
| {false, 0}, |
| {true, 50.16}, |
| {true, 33.441}, |
| {true, 16.72}, |
| {false, 16.72}, |
| {true, 117.041}, |
| {true, 16.72}, |
| {false, 16.72}, |
| {true, 50.161}, |
| {true, 50.16}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 16.72}, |
| {false, 0}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 33.44}, |
| {true, 16.72}, |
| {false, 16.721}, |
| {true, 66.881}, |
| {false, 0}, |
| {true, 33.441}, |
| {true, 16.72}, |
| {true, 50.16}, |
| {true, 16.72}, |
| {false, 16.721}, |
| {true, 50.161}, |
| {true, 50.16}, |
| {false, 0}, |
| {true, 33.441}, |
| {true, 50.337}, |
| {true, 50.183}, |
| {true, 16.722}, |
| {true, 50.161}, |
| {true, 33.441}, |
| {true, 50.16}, |
| {true, 33.441}, |
| {true, 50.16}, |
| {true, 33.441}, |
| {true, 50.16}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {true, 50.16}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {true, 50.16}, |
| {true, 50.161}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {true, 50.16}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {true, 33.44}, |
| {true, 83.601}, |
| {true, 16.72}, |
| {true, 33.44}, |
| {false, 0}}; |
| |
| SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, 3); |
| ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler); |
| } |
| |
| TEST(SmoothEventSamplerTest, DrawingAt30FpsWith60HzVsyncSampledAt30Hertz) { |
| // Actual capturing of timing data: Initial instability as a 30 FPS video was |
| // started from a still screen, then followed by steady-state. Drawing |
| // framerate from the video rendering was a bit volatile, but averaged 30 FPS. |
| static const DataPoint data_points[] = {{true, 2407.69}, |
| {true, 16.733}, |
| {true, 217.362}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 16.721}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 50.161}, |
| {true, 50.16}, |
| {false, 0}, |
| {true, 50.161}, |
| {true, 33.44}, |
| {true, 16.72}, |
| {false, 0}, |
| {false, 16.72}, |
| {true, 66.881}, |
| {false, 0}, |
| {true, 33.44}, |
| {true, 16.72}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 33.538}, |
| {true, 33.526}, |
| {true, 33.447}, |
| {true, 33.445}, |
| {true, 33.441}, |
| {true, 16.721}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {true, 16.72}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {false, 0}, |
| {false, 16.72}, |
| {true, 66.881}, |
| {true, 16.72}, |
| {false, 16.72}, |
| {true, 50.16}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {true, 16.72}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 66.88}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 50.16}, |
| {false, 0.001}, |
| {true, 16.721}, |
| {true, 66.88}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 50.161}, |
| {true, 16.72}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.72}, |
| {true, 66.881}, |
| {true, 33.44}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {false, 16.72}, |
| {true, 66.88}, |
| {true, 16.721}, |
| {true, 50.16}, |
| {true, 33.44}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {true, 33.44}}; |
| |
| SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, 3); |
| ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler); |
| } |
| |
| TEST(SmoothEventSamplerTest, DrawingAt60FpsWith60HzVsyncSampledAt30Hertz) { |
| // Actual capturing of timing data: WebGL Acquarium demo |
| // (http://webglsamples.googlecode.com/hg/aquarium/aquarium.html) which ran |
| // between 55-60 FPS in the steady-state. |
| static const DataPoint data_points[] = {{true, 16.72}, |
| {true, 16.72}, |
| {true, 4163.29}, |
| {true, 50.193}, |
| {true, 117.041}, |
| {true, 50.161}, |
| {true, 50.16}, |
| {true, 33.441}, |
| {true, 50.16}, |
| {true, 33.44}, |
| {false, 0}, |
| {false, 0}, |
| {true, 50.161}, |
| {true, 83.601}, |
| {true, 50.16}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {false, 16.72}, |
| {true, 50.16}, |
| {true, 16.72}, |
| {false, 0.001}, |
| {true, 33.441}, |
| {false, 16.72}, |
| {true, 16.72}, |
| {true, 50.16}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.72}, |
| {true, 16.72}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.721}, |
| {true, 16.721}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.72}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 16.721}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.72}, |
| {true, 16.72}, |
| {true, 50.16}, |
| {false, 0}, |
| {true, 16.721}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.721}, |
| {true, 16.721}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.441}, |
| {false, 16.72}, |
| {true, 16.72}, |
| {true, 50.16}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.72}, |
| {true, 16.721}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.44}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 33.44}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.441}, |
| {false, 16.72}, |
| {true, 16.72}, |
| {true, 50.16}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.441}, |
| {false, 0}, |
| {true, 33.44}, |
| {false, 16.72}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 16.721}, |
| {true, 50.161}, |
| {false, 0}, |
| {true, 16.72}, |
| {true, 33.44}, |
| {false, 0}, |
| {true, 33.441}, |
| {false, 16.72}, |
| {true, 16.72}, |
| {true, 50.16}}; |
| |
| SmoothEventSampler sampler(base::TimeDelta::FromSeconds(1) / 30, 3); |
| ReplayCheckingSamplerDecisions(data_points, arraysize(data_points), &sampler); |
| } |
| |
| } // namespace media |
