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(50, regular_frame_interval_ms);
  54     InsertFramesWithInterval(50, 110);
  55     overuse_detector_->Process();
  56
  57     InsertFramesWithInterval(50, 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   TriggerOveruse();
  78 }
  79
  80 TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
  81   TriggerOveruse();
  82   TriggerNormalUsage();
  83 }
  84
  85 TEST_F(OveruseFrameDetectorTest, DoubleOveruseAndRecover) {
  86   TriggerOveruse();
  87   TriggerOveruse();
  88   TriggerNormalUsage();
  89 }
  90
  91 TEST_F(OveruseFrameDetectorTest, ConstantOveruseGivesNoNormalUsage) {
  92   EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
  93
  94   for(size_t i = 0; i < 64; ++i)
  95     TriggerOveruse();
  96 }
  97
  98 TEST_F(OveruseFrameDetectorTest, LastCaptureJitter) {
  99   EXPECT_EQ(-1, overuse_detector_->last_capture_jitter_ms());
 100   TriggerOveruse();
 101   EXPECT_GT(overuse_detector_->last_capture_jitter_ms(), 0);
 102 }
 103
 104 TEST_F(OveruseFrameDetectorTest, NoCaptureQueueDelay) {
 105   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 0);
 106   overuse_detector_->FrameCaptured(320, 180);
 107   overuse_detector_->FrameProcessingStarted();
 108   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 0);
 109 }
 110
 111 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelay) {
 112   overuse_detector_->FrameCaptured(320, 180);
 113   clock_->AdvanceTimeMilliseconds(100);
 114   overuse_detector_->FrameProcessingStarted();
 115   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 116 }
 117
 118 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayMultipleFrames) {
 119   overuse_detector_->FrameCaptured(320, 180);
 120   clock_->AdvanceTimeMilliseconds(10);
 121   overuse_detector_->FrameCaptured(320, 180);
 122   clock_->AdvanceTimeMilliseconds(20);
 123
 124   overuse_detector_->FrameProcessingStarted();
 125   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 30);
 126   overuse_detector_->FrameProcessingStarted();
 127   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
 128 }
 129
 130 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayResetAtResolutionSwitch) {
 131   overuse_detector_->FrameCaptured(320, 180);
 132   clock_->AdvanceTimeMilliseconds(10);
 133   overuse_detector_->FrameCaptured(321, 180);
 134   clock_->AdvanceTimeMilliseconds(20);
 135
 136   overuse_detector_->FrameProcessingStarted();
 137   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
 138 }
 139
 140 TEST_F(OveruseFrameDetectorTest, CaptureQueueDelayNoMatchingCapturedFrame) {
 141   overuse_detector_->FrameCaptured(320, 180);
 142   clock_->AdvanceTimeMilliseconds(100);
 143   overuse_detector_->FrameProcessingStarted();
 144   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 145   // No new captured frame. The last delay should be reported.
 146   overuse_detector_->FrameProcessingStarted();
 147   EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 100);
 148 }
 149
 150 TEST_F(OveruseFrameDetectorTest, EncodedFrame) {
 151   const int kInitialAvgEncodeTimeInMs = 5;
 152   EXPECT_EQ(kInitialAvgEncodeTimeInMs, overuse_detector_->AvgEncodeTimeMs());
 153   for (int i = 0; i < 30; i++) {
 154     clock_->AdvanceTimeMilliseconds(33);
 155     overuse_detector_->FrameEncoded(2);
 156   }
 157   EXPECT_EQ(2, overuse_detector_->AvgEncodeTimeMs());
 158 }
 159
 160 TEST_F(OveruseFrameDetectorTest, EncodedUsage) {
 161   for (int i = 0; i < 30; i++) {
 162     overuse_detector_->FrameCaptured(320, 180);
 163     clock_->AdvanceTimeMilliseconds(5);
 164     overuse_detector_->FrameEncoded(5);
 165     clock_->AdvanceTimeMilliseconds(33-5);
 166   }
 167   EXPECT_EQ(15, overuse_detector_->EncodeUsagePercent());
 168 }
 169
 170 }  // namespace webrtc