Upstream version 5.34.92.0
[platform/framework/web/crosswalk.git] / 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