media/capture/video_capture_oracle_unittest.cc

   1 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/capture/video_capture_oracle.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace media {
  11
  12 namespace {
  13
  14 base::TimeTicks InitialTestTimeTicks() {
  15   return base::TimeTicks() + base::TimeDelta::FromSeconds(1);
  16 }
  17
  18 }  // namespace
  19
  20 // Tests that VideoCaptureOracle filters out events whose timestamps are
  21 // decreasing.
  22 TEST(VideoCaptureOracleTest, EnforcesEventTimeMonotonicity) {
  23   const base::TimeDelta min_capture_period =
  24       base::TimeDelta::FromSeconds(1) / 30;
  25   const gfx::Rect damage_rect(0, 0, 1280, 720);
  26   const base::TimeDelta event_increment = min_capture_period * 2;
  27
  28   VideoCaptureOracle oracle(min_capture_period);
  29
  30   base::TimeTicks t = InitialTestTimeTicks();
  31   for (int i = 0; i < 10; ++i) {
  32     t += event_increment;
  33     ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
  34         VideoCaptureOracle::kCompositorUpdate,
  35         damage_rect, t));
  36   }
  37
  38   base::TimeTicks furthest_event_time = t;
  39   for (int i = 0; i < 10; ++i) {
  40     t -= event_increment;
  41     ASSERT_FALSE(oracle.ObserveEventAndDecideCapture(
  42         VideoCaptureOracle::kCompositorUpdate,
  43         damage_rect, t));
  44   }
  45
  46   t = furthest_event_time;
  47   for (int i = 0; i < 10; ++i) {
  48     t += event_increment;
  49     ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
  50         VideoCaptureOracle::kCompositorUpdate,
  51         damage_rect, t));
  52   }
  53 }
  54
  55 // Tests that VideoCaptureOracle is enforcing the requirement that
  56 // successfully captured frames are delivered in order.  Otherwise, downstream
  57 // consumers could be tripped-up by out-of-order frames or frame timestamps.
  58 TEST(VideoCaptureOracleTest, EnforcesFramesDeliveredInOrder) {
  59   const base::TimeDelta min_capture_period =
  60       base::TimeDelta::FromSeconds(1) / 30;
  61   const gfx::Rect damage_rect(0, 0, 1280, 720);
  62   const base::TimeDelta event_increment = min_capture_period * 2;
  63
  64   VideoCaptureOracle oracle(min_capture_period);
  65
  66   // Most basic scenario: Frames delivered one at a time, with no additional
  67   // captures in-between deliveries.
  68   base::TimeTicks t = InitialTestTimeTicks();
  69   int last_frame_number;
  70   base::TimeTicks ignored;
  71   for (int i = 0; i < 10; ++i) {
  72     t += event_increment;
  73     ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
  74         VideoCaptureOracle::kCompositorUpdate,
  75         damage_rect, t));
  76     last_frame_number = oracle.RecordCapture();
  77     ASSERT_TRUE(oracle.CompleteCapture(last_frame_number, true, &ignored));
  78   }
  79
  80   // Basic pipelined scenario: More than one frame in-flight at delivery points.
  81   for (int i = 0; i < 50; ++i) {
  82     const int num_in_flight = 1 + i % 3;
  83     for (int j = 0; j < num_in_flight; ++j) {
  84       t += event_increment;
  85       ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
  86           VideoCaptureOracle::kCompositorUpdate,
  87           damage_rect, t));
  88       last_frame_number = oracle.RecordCapture();
  89     }
  90     for (int j = num_in_flight - 1; j >= 0; --j) {
  91       ASSERT_TRUE(
  92           oracle.CompleteCapture(last_frame_number - j, true, &ignored));
  93     }
  94   }
  95
  96   // Pipelined scenario with successful out-of-order delivery attempts
  97   // rejected.
  98   for (int i = 0; i < 50; ++i) {
  99     const int num_in_flight = 1 + i % 3;
 100     for (int j = 0; j < num_in_flight; ++j) {
 101       t += event_increment;
 102       ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
 103           VideoCaptureOracle::kCompositorUpdate,
 104           damage_rect, t));
 105       last_frame_number = oracle.RecordCapture();
 106     }
 107     ASSERT_TRUE(oracle.CompleteCapture(last_frame_number, true, &ignored));
 108     for (int j = 1; j < num_in_flight; ++j) {
 109       ASSERT_FALSE(
 110           oracle.CompleteCapture(last_frame_number - j, true, &ignored));
 111     }
 112   }
 113
 114   // Pipelined scenario with successful delivery attempts accepted after an
 115   // unsuccessful out of order delivery attempt.
 116   for (int i = 0; i < 50; ++i) {
 117     const int num_in_flight = 1 + i % 3;
 118     for (int j = 0; j < num_in_flight; ++j) {
 119       t += event_increment;
 120       ASSERT_TRUE(oracle.ObserveEventAndDecideCapture(
 121           VideoCaptureOracle::kCompositorUpdate,
 122           damage_rect, t));
 123       last_frame_number = oracle.RecordCapture();
 124     }
 125     // Report the last frame as an out of order failure.
 126     ASSERT_FALSE(oracle.CompleteCapture(last_frame_number, false, &ignored));
 127     for (int j = 1; j < num_in_flight - 1; ++j) {
 128       ASSERT_TRUE(
 129           oracle.CompleteCapture(last_frame_number - j, true, &ignored));
 130     }
 131
 132   }
 133 }
 134
 135 // Tests that VideoCaptureOracle transitions between using its two samplers in a
 136 // way that does not introduce severe jank, pauses, etc.
 137 TEST(VideoCaptureOracleTest, TransitionsSmoothlyBetweenSamplers) {
 138   const base::TimeDelta min_capture_period =
 139       base::TimeDelta::FromSeconds(1) / 30;
 140   const gfx::Rect animation_damage_rect(0, 0, 1280, 720);
 141   const base::TimeDelta event_increment = min_capture_period * 2;
 142
 143   VideoCaptureOracle oracle(min_capture_period);
 144
 145   // Run sequences of animation events and non-animation events through the
 146   // oracle.  As the oracle transitions between each sampler, make sure the
 147   // frame timestamps won't trip-up downstream consumers.
 148   base::TimeTicks t = InitialTestTimeTicks();
 149   base::TimeTicks last_frame_timestamp;
 150   for (int i = 0; i < 1000; ++i) {
 151     t += event_increment;
 152
 153     // For every 100 events, provide 50 that will cause the
 154     // AnimatedContentSampler to lock-in, followed by 50 that will cause it to
 155     // lock-out (i.e., the oracle will use the SmoothEventSampler instead).
 156     const bool provide_animated_content_event =
 157         (i % 100) >= 25 && (i % 100) < 75;
 158
 159     // Only the few events that trigger the lock-out transition should be
 160     // dropped, because the AnimatedContentSampler doesn't yet realize the
 161     // animation ended.  Otherwise, the oracle should always decide to sample
 162     // because one of its samplers says to.
 163     const bool require_oracle_says_sample = (i % 100) < 75 || (i % 100) >= 78;
 164     const bool oracle_says_sample = oracle.ObserveEventAndDecideCapture(
 165         VideoCaptureOracle::kCompositorUpdate,
 166         provide_animated_content_event ? animation_damage_rect : gfx::Rect(),
 167         t);
 168     if (require_oracle_says_sample)
 169       ASSERT_TRUE(oracle_says_sample);
 170     if (!oracle_says_sample) {
 171       ASSERT_EQ(base::TimeDelta(), oracle.estimated_frame_duration());
 172       continue;
 173     }
 174     ASSERT_LT(base::TimeDelta(), oracle.estimated_frame_duration());
 175
 176     const int frame_number = oracle.RecordCapture();
 177
 178     base::TimeTicks frame_timestamp;
 179     ASSERT_TRUE(oracle.CompleteCapture(frame_number, true, &frame_timestamp));
 180     ASSERT_FALSE(frame_timestamp.is_null());
 181     if (!last_frame_timestamp.is_null()) {
 182       const base::TimeDelta delta = frame_timestamp - last_frame_timestamp;
 183       EXPECT_LE(event_increment.InMicroseconds(), delta.InMicroseconds());
 184       // Right after the AnimatedContentSampler lock-out transition, there were
 185       // a few frames dropped, so allow a gap in the timestamps.  Otherwise, the
 186       // delta between frame timestamps should never be more than 2X the
 187       // |event_increment|.
 188       const base::TimeDelta max_acceptable_delta = (i % 100) == 78 ?
 189           event_increment * 5 : event_increment * 2;
 190       EXPECT_GE(max_acceptable_delta.InMicroseconds(), delta.InMicroseconds());
 191     }
 192     last_frame_timestamp = frame_timestamp;
 193   }
 194 }
 195
 196 // Tests that VideoCaptureOracle prevents timer polling from initiating
 197 // simultaneous captures.
 198 TEST(VideoCaptureOracleTest, SamplesOnlyOneOverdueFrameAtATime) {
 199   const base::TimeDelta min_capture_period =
 200       base::TimeDelta::FromSeconds(1) / 30;
 201   const base::TimeDelta vsync_interval =
 202       base::TimeDelta::FromSeconds(1) / 60;
 203   const base::TimeDelta timer_interval = base::TimeDelta::FromMilliseconds(
 204       VideoCaptureOracle::kMinTimerPollPeriodMillis);
 205
 206   VideoCaptureOracle oracle(min_capture_period);
 207
 208   // Have the oracle observe some compositor events.  Simulate that each capture
 209   // completes successfully.
 210   base::TimeTicks t = InitialTestTimeTicks();
 211   base::TimeTicks ignored;
 212   bool did_complete_a_capture = false;
 213   for (int i = 0; i < 10; ++i) {
 214     t += vsync_interval;
 215     if (oracle.ObserveEventAndDecideCapture(
 216             VideoCaptureOracle::kCompositorUpdate, gfx::Rect(), t)) {
 217       ASSERT_TRUE(
 218           oracle.CompleteCapture(oracle.RecordCapture(), true, &ignored));
 219       did_complete_a_capture = true;
 220     }
 221   }
 222   ASSERT_TRUE(did_complete_a_capture);
 223
 224   // Start one more compositor-based capture, but do not notify of completion
 225   // yet.
 226   for (int i = 0; i <= 10; ++i) {
 227     ASSERT_GT(10, i) << "BUG: Seems like it'll never happen!";
 228     t += vsync_interval;
 229     if (oracle.ObserveEventAndDecideCapture(
 230             VideoCaptureOracle::kCompositorUpdate, gfx::Rect(), t)) {
 231       break;
 232     }
 233   }
 234   int frame_number = oracle.RecordCapture();
 235
 236   // Stop providing the compositor events and start providing timer polling
 237   // events.  No overdue samplings should be recommended because of the
 238   // not-yet-complete compositor-based capture.
 239   for (int i = 0; i < 10; ++i) {
 240     t += timer_interval;
 241     ASSERT_FALSE(oracle.ObserveEventAndDecideCapture(
 242         VideoCaptureOracle::kTimerPoll, gfx::Rect(), t));
 243   }
 244
 245   // Now, complete the oustanding compositor-based capture and continue
 246   // providing timer polling events.  The oracle should start recommending
 247   // sampling again.
 248   ASSERT_TRUE(oracle.CompleteCapture(frame_number, true, &ignored));
 249   did_complete_a_capture = false;
 250   for (int i = 0; i < 10; ++i) {
 251     t += timer_interval;
 252     if (oracle.ObserveEventAndDecideCapture(
 253             VideoCaptureOracle::kTimerPoll, gfx::Rect(), t)) {
 254       ASSERT_TRUE(
 255           oracle.CompleteCapture(oracle.RecordCapture(), true, &ignored));
 256       did_complete_a_capture = true;
 257     }
 258   }
 259   ASSERT_TRUE(did_complete_a_capture);
 260
 261   // Start one more timer-based capture, but do not notify of completion yet.
 262   for (int i = 0; i <= 10; ++i) {
 263     ASSERT_GT(10, i) << "BUG: Seems like it'll never happen!";
 264     t += timer_interval;
 265     if (oracle.ObserveEventAndDecideCapture(
 266             VideoCaptureOracle::kTimerPoll, gfx::Rect(), t)) {
 267       break;
 268     }
 269   }
 270   frame_number = oracle.RecordCapture();
 271
 272   // Confirm that the oracle does not recommend sampling until the outstanding
 273   // timer-based capture completes.
 274   for (int i = 0; i < 10; ++i) {
 275     t += timer_interval;
 276     ASSERT_FALSE(oracle.ObserveEventAndDecideCapture(
 277         VideoCaptureOracle::kTimerPoll, gfx::Rect(), t));
 278   }
 279   ASSERT_TRUE(oracle.CompleteCapture(frame_number, true, &ignored));
 280   for (int i = 0; i <= 10; ++i) {
 281     ASSERT_GT(10, i) << "BUG: Seems like it'll never happen!";
 282     t += timer_interval;
 283     if (oracle.ObserveEventAndDecideCapture(
 284             VideoCaptureOracle::kTimerPoll, gfx::Rect(), t)) {
 285       break;
 286     }
 287   }
 288 }
 289
 290 }  // namespace media