src/third_party/webrtc/video_engine/overuse_frame_detector_unittest.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 #include "webrtc/system_wrappers/interface/clock.h"
  15 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  16 #include "webrtc/video_engine/include/vie_base.h"
  17 #include "webrtc/video_engine/overuse_frame_detector.h"
  18
  19 namespace webrtc {
  20
  21 class MockCpuOveruseObserver : public CpuOveruseObserver {
  22  public:
  23   MockCpuOveruseObserver() {}
  24   virtual ~MockCpuOveruseObserver() {}
  25
  26   MOCK_METHOD0(OveruseDetected, void());
  27   MOCK_METHOD0(NormalUsage, void());
  28 };
  29
  30 class OveruseFrameDetectorTest : public ::testing::Test {
  31  protected:
  32   virtual void SetUp() {
  33     clock_.reset(new SimulatedClock(1234));
  34     observer_.reset(new MockCpuOveruseObserver());
  35     overuse_detector_.reset(new OveruseFrameDetector(clock_.get(),
  36                                                      10.0f,
  37                                                      15.0f));
  38     overuse_detector_->SetObserver(observer_.get());
  39   }
  40
  41   void InsertFramesWithInterval(size_t num_frames, int interval_ms) {
  42     while (num_frames-- > 0) {
  43       clock_->AdvanceTimeMilliseconds(interval_ms);
  44       overuse_detector_->FrameCaptured(640, 480);
  45     }
  46   }
  47
  48   void TriggerOveruse() {
  49     int regular_frame_interval_ms = 33;
  50
  51     EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
  52
  53     InsertFramesWithInterval(200, regular_frame_interval_ms);
  54     InsertFramesWithInterval(50, 110);
  55     overuse_detector_->Process();
  56
  57     InsertFramesWithInterval(200, regular_frame_interval_ms);
  58     InsertFramesWithInterval(50, 110);
  59     overuse_detector_->Process();
  60   }
  61
  62   void TriggerNormalUsage() {
  63     int regular_frame_interval_ms = 33;
  64
  65     EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
  66
  67     InsertFramesWithInterval(900, regular_frame_interval_ms);
  68     overuse_detector_->Process();
  69   }
  70
  71   scoped_ptr<SimulatedClock> clock_;
  72   scoped_ptr<MockCpuOveruseObserver> observer_;
  73   scoped_ptr<OveruseFrameDetector> overuse_detector_;
  74 };
  75
  76 TEST_F(OveruseFrameDetectorTest, TriggerOveruse) {
  77   overuse_detector_->set_min_process_count_before_reporting(0);
  78   TriggerOveruse();
  79 }
  80
  81 TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
  82   overuse_detector_->set_min_process_count_before_reporting(0);
  83   TriggerOveruse();
  84   TriggerNormalUsage();
  85 }
  86
  87 TEST_F(OveruseFrameDetectorTest, DoubleOveruseAndRecover) {
  88   overuse_detector_->set_min_process_count_before_reporting(0);
  89   TriggerOveruse();
  90   TriggerOveruse();
  91   TriggerNormalUsage();
  92 }
  93
  94 TEST_F(OveruseFrameDetectorTest, TriggerNormalUsageWithMinProcessCount) {
  95   overuse_detector_->set_min_process_count_before_reporting(1);
  96   InsertFramesWithInterval(900, 33);
  97   overuse_detector_->Process();
  98   EXPECT_EQ(-1, overuse_detector_->last_capture_jitter_ms());
  99   clock_->AdvanceTimeMilliseconds(5000);
 100   overuse_detector_->Process();
 101   EXPECT_GT(overuse_detector_->last_capture_jitter_ms(), 0);
 102 }
 103
 104 TEST_F(OveruseFrameDetectorTest, ConstantOveruseGivesNoNormalUsage) {
 105   overuse_detector_->set_min_process_count_before_reporting(0);
 106   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
 107
 108   for(size_t i = 0; i < 64; ++i)
 109     TriggerOveruse();
 110 }
 111
 112 TEST_F(OveruseFrameDetectorTest, LastCaptureJitter) {
 113   overuse_detector_->set_min_process_count_before_reporting(0);
 114   EXPECT_EQ(-1, overuse_detector_->last_capture_jitter_ms());
 115   TriggerOveruse();
 116   EXPECT_GT(overuse_detector_->last_capture_jitter_ms(), 0);
 117 }
 118
 119 TEST_F(OveruseFrameDetectorTest, NoCaptureQueueDelay) {
 120   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 0);
 121   overuse_detector_->FrameCaptured(320, 180);
 122   overuse_detector_->FrameProcessingStarted();
 123   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 0);
 124 }
 125
 126 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelay) {
 127   overuse_detector_->FrameCaptured(320, 180);
 128   clock_->AdvanceTimeMilliseconds(100);
 129   overuse_detector_->FrameProcessingStarted();
 130   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 131 }
 132
 133 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayMultipleFrames) {
 134   overuse_detector_->FrameCaptured(320, 180);
 135   clock_->AdvanceTimeMilliseconds(10);
 136   overuse_detector_->FrameCaptured(320, 180);
 137   clock_->AdvanceTimeMilliseconds(20);
 138
 139   overuse_detector_->FrameProcessingStarted();
 140   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 30);
 141   overuse_detector_->FrameProcessingStarted();
 142   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
 143 }
 144
 145 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayResetAtResolutionSwitch) {
 146   overuse_detector_->FrameCaptured(320, 180);
 147   clock_->AdvanceTimeMilliseconds(10);
 148   overuse_detector_->FrameCaptured(321, 180);
 149   clock_->AdvanceTimeMilliseconds(20);
 150
 151   overuse_detector_->FrameProcessingStarted();
 152   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
 153 }
 154
 155 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayNoMatchingCapturedFrame) {
 156   overuse_detector_->FrameCaptured(320, 180);
 157   clock_->AdvanceTimeMilliseconds(100);
 158   overuse_detector_->FrameProcessingStarted();
 159   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 160   // No new captured frame. The last delay should be reported.
 161   overuse_detector_->FrameProcessingStarted();
 162   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 163 }
 164
 165 TEST_F(OveruseFrameDetectorTest, EncodedFrame) {
 166   const int kInitialAvgEncodeTimeInMs = 5;
 167   EXPECT_EQ(kInitialAvgEncodeTimeInMs, overuse_detector_->AvgEncodeTimeMs());
 168   for (int i = 0; i < 30; i++) {
 169     clock_->AdvanceTimeMilliseconds(33);
 170     overuse_detector_->FrameEncoded(2);
 171   }
 172   EXPECT_EQ(2, overuse_detector_->AvgEncodeTimeMs());
 173 }
 174
 175 TEST_F(OveruseFrameDetectorTest, EncodedUsage) {
 176   for (int i = 0; i < 30; i++) {
 177     overuse_detector_->FrameCaptured(320, 180);
 178     clock_->AdvanceTimeMilliseconds(5);
 179     overuse_detector_->FrameEncoded(5);
 180     clock_->AdvanceTimeMilliseconds(33-5);
 181   }
 182   EXPECT_EQ(15, overuse_detector_->EncodeUsagePercent());
 183 }
 184
 185 }  // namespace webrtc