2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
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.
11 #include "testing/gmock/include/gmock/gmock.h"
12 #include "testing/gtest/include/gtest/gtest.h"
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"
21 class MockCpuOveruseObserver : public CpuOveruseObserver {
23 MockCpuOveruseObserver() {}
24 virtual ~MockCpuOveruseObserver() {}
26 MOCK_METHOD0(OveruseDetected, void());
27 MOCK_METHOD0(NormalUsage, void());
30 class OveruseFrameDetectorTest : public ::testing::Test {
32 virtual void SetUp() {
33 clock_.reset(new SimulatedClock(1234));
34 observer_.reset(new MockCpuOveruseObserver());
35 overuse_detector_.reset(new OveruseFrameDetector(clock_.get(),
38 overuse_detector_->SetObserver(observer_.get());
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);
48 void TriggerOveruse() {
49 int regular_frame_interval_ms = 33;
51 EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
53 InsertFramesWithInterval(50, regular_frame_interval_ms);
54 InsertFramesWithInterval(50, 110);
55 overuse_detector_->Process();
57 InsertFramesWithInterval(50, regular_frame_interval_ms);
58 InsertFramesWithInterval(50, 110);
59 overuse_detector_->Process();
62 void TriggerNormalUsage() {
63 int regular_frame_interval_ms = 33;
65 EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
67 InsertFramesWithInterval(900, regular_frame_interval_ms);
68 overuse_detector_->Process();
71 scoped_ptr<SimulatedClock> clock_;
72 scoped_ptr<MockCpuOveruseObserver> observer_;
73 scoped_ptr<OveruseFrameDetector> overuse_detector_;
76 TEST_F(OveruseFrameDetectorTest, TriggerOveruse) {
80 TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
85 TEST_F(OveruseFrameDetectorTest, DoubleOveruseAndRecover) {
91 TEST_F(OveruseFrameDetectorTest, ConstantOveruseGivesNoNormalUsage) {
92 EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
94 for(size_t i = 0; i < 64; ++i)
98 TEST_F(OveruseFrameDetectorTest, LastCaptureJitter) {
99 EXPECT_EQ(-1, overuse_detector_->last_capture_jitter_ms());
101 EXPECT_GT(overuse_detector_->last_capture_jitter_ms(), 0);
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);
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);
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);
124 overuse_detector_->FrameProcessingStarted();
125 EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 30);
126 overuse_detector_->FrameProcessingStarted();
127 EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
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);
136 overuse_detector_->FrameProcessingStarted();
137 EXPECT_EQ(overuse_detector_->CaptureQueueDelayMsPerS(), 20);
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);
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);
157 EXPECT_EQ(2, overuse_detector_->AvgEncodeTimeMs());
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);
167 EXPECT_EQ(15, overuse_detector_->EncodeUsagePercent());
170 } // namespace webrtc