OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (c) 2012 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 | |
12 // This file includes unit tests for ViERemb. | |
13 | |
14 #include <vector> | |
15 | |
16 #include "testing/gmock/include/gmock/gmock.h" | |
17 #include "testing/gtest/include/gtest/gtest.h" | |
18 #include "webrtc/base/scoped_ptr.h" | |
19 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" | |
20 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" | |
21 #include "webrtc/modules/utility/include/mock/mock_process_thread.h" | |
22 #include "webrtc/system_wrappers/include/tick_util.h" | |
23 #include "webrtc/video/vie_remb.h" | |
24 | |
25 using ::testing::_; | |
26 using ::testing::AnyNumber; | |
27 using ::testing::NiceMock; | |
28 using ::testing::Return; | |
29 | |
30 namespace webrtc { | |
31 | |
32 class ViERembTest : public ::testing::Test { | |
33 protected: | |
34 virtual void SetUp() { | |
35 TickTime::UseFakeClock(12345); | |
36 process_thread_.reset(new NiceMock<MockProcessThread>); | |
37 vie_remb_.reset(new VieRemb()); | |
38 } | |
39 rtc::scoped_ptr<MockProcessThread> process_thread_; | |
40 rtc::scoped_ptr<VieRemb> vie_remb_; | |
41 }; | |
42 | |
43 TEST_F(ViERembTest, OneModuleTestForSendingRemb) { | |
44 MockRtpRtcp rtp; | |
45 vie_remb_->AddReceiveChannel(&rtp); | |
46 vie_remb_->AddRembSender(&rtp); | |
47 | |
48 const unsigned int bitrate_estimate = 456; | |
49 unsigned int ssrc = 1234; | |
50 std::vector<unsigned int> ssrcs(&ssrc, &ssrc + 1); | |
51 | |
52 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
53 | |
54 TickTime::AdvanceFakeClock(1000); | |
55 EXPECT_CALL(rtp, SetREMBData(bitrate_estimate, ssrcs)) | |
56 .Times(1); | |
57 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
58 | |
59 // Lower bitrate to send another REMB packet. | |
60 EXPECT_CALL(rtp, SetREMBData(bitrate_estimate - 100, ssrcs)) | |
61 .Times(1); | |
62 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate - 100); | |
63 | |
64 vie_remb_->RemoveReceiveChannel(&rtp); | |
65 vie_remb_->RemoveRembSender(&rtp); | |
66 } | |
67 | |
68 TEST_F(ViERembTest, LowerEstimateToSendRemb) { | |
69 MockRtpRtcp rtp; | |
70 vie_remb_->AddReceiveChannel(&rtp); | |
71 vie_remb_->AddRembSender(&rtp); | |
72 | |
73 unsigned int bitrate_estimate = 456; | |
74 unsigned int ssrc = 1234; | |
75 std::vector<unsigned int> ssrcs(&ssrc, &ssrc + 1); | |
76 | |
77 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
78 // Call OnReceiveBitrateChanged twice to get a first estimate. | |
79 TickTime::AdvanceFakeClock(1000); | |
80 EXPECT_CALL(rtp, SetREMBData(bitrate_estimate, ssrcs)) | |
81 .Times(1); | |
82 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
83 | |
84 // Lower the estimate with more than 3% to trigger a call to SetREMBData right | |
85 // away. | |
86 bitrate_estimate = bitrate_estimate - 100; | |
87 EXPECT_CALL(rtp, SetREMBData(bitrate_estimate, ssrcs)) | |
88 .Times(1); | |
89 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
90 } | |
91 | |
92 TEST_F(ViERembTest, VerifyIncreasingAndDecreasing) { | |
93 MockRtpRtcp rtp_0; | |
94 MockRtpRtcp rtp_1; | |
95 vie_remb_->AddReceiveChannel(&rtp_0); | |
96 vie_remb_->AddRembSender(&rtp_0); | |
97 vie_remb_->AddReceiveChannel(&rtp_1); | |
98 | |
99 unsigned int bitrate_estimate[] = { 456, 789 }; | |
100 unsigned int ssrc[] = { 1234, 5678 }; | |
101 std::vector<unsigned int> ssrcs(ssrc, ssrc + sizeof(ssrc) / sizeof(ssrc[0])); | |
102 | |
103 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate[0]); | |
104 | |
105 // Call OnReceiveBitrateChanged twice to get a first estimate. | |
106 EXPECT_CALL(rtp_0, SetREMBData(bitrate_estimate[0], ssrcs)) | |
107 .Times(1); | |
108 TickTime::AdvanceFakeClock(1000); | |
109 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate[0]); | |
110 | |
111 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate[1] + 100); | |
112 | |
113 // Lower the estimate to trigger a callback. | |
114 EXPECT_CALL(rtp_0, SetREMBData(bitrate_estimate[1], ssrcs)) | |
115 .Times(1); | |
116 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate[1]); | |
117 | |
118 vie_remb_->RemoveReceiveChannel(&rtp_0); | |
119 vie_remb_->RemoveRembSender(&rtp_0); | |
120 vie_remb_->RemoveReceiveChannel(&rtp_1); | |
121 } | |
122 | |
123 TEST_F(ViERembTest, NoRembForIncreasedBitrate) { | |
124 MockRtpRtcp rtp_0; | |
125 MockRtpRtcp rtp_1; | |
126 vie_remb_->AddReceiveChannel(&rtp_0); | |
127 vie_remb_->AddRembSender(&rtp_0); | |
128 vie_remb_->AddReceiveChannel(&rtp_1); | |
129 | |
130 unsigned int bitrate_estimate = 456; | |
131 unsigned int ssrc[] = { 1234, 5678 }; | |
132 std::vector<unsigned int> ssrcs(ssrc, ssrc + sizeof(ssrc) / sizeof(ssrc[0])); | |
133 | |
134 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
135 // Call OnReceiveBitrateChanged twice to get a first estimate. | |
136 TickTime::AdvanceFakeClock(1000); | |
137 EXPECT_CALL(rtp_0, SetREMBData(bitrate_estimate, ssrcs)) | |
138 .Times(1); | |
139 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
140 | |
141 // Increased estimate shouldn't trigger a callback right away. | |
142 EXPECT_CALL(rtp_0, SetREMBData(_, _)) | |
143 .Times(0); | |
144 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate + 1); | |
145 | |
146 // Decreasing the estimate less than 3% shouldn't trigger a new callback. | |
147 EXPECT_CALL(rtp_0, SetREMBData(_, _)) | |
148 .Times(0); | |
149 int lower_estimate = bitrate_estimate * 98 / 100; | |
150 vie_remb_->OnReceiveBitrateChanged(ssrcs, lower_estimate); | |
151 | |
152 vie_remb_->RemoveReceiveChannel(&rtp_1); | |
153 vie_remb_->RemoveReceiveChannel(&rtp_0); | |
154 vie_remb_->RemoveRembSender(&rtp_0); | |
155 } | |
156 | |
157 TEST_F(ViERembTest, ChangeSendRtpModule) { | |
158 MockRtpRtcp rtp_0; | |
159 MockRtpRtcp rtp_1; | |
160 vie_remb_->AddReceiveChannel(&rtp_0); | |
161 vie_remb_->AddRembSender(&rtp_0); | |
162 vie_remb_->AddReceiveChannel(&rtp_1); | |
163 | |
164 unsigned int bitrate_estimate = 456; | |
165 unsigned int ssrc[] = { 1234, 5678 }; | |
166 std::vector<unsigned int> ssrcs(ssrc, ssrc + sizeof(ssrc) / sizeof(ssrc[0])); | |
167 | |
168 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
169 // Call OnReceiveBitrateChanged twice to get a first estimate. | |
170 TickTime::AdvanceFakeClock(1000); | |
171 EXPECT_CALL(rtp_0, SetREMBData(bitrate_estimate, ssrcs)) | |
172 .Times(1); | |
173 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
174 | |
175 // Decrease estimate to trigger a REMB. | |
176 bitrate_estimate = bitrate_estimate - 100; | |
177 EXPECT_CALL(rtp_0, SetREMBData(bitrate_estimate, ssrcs)) | |
178 .Times(1); | |
179 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
180 | |
181 // Remove the sending module, add it again -> should get remb on the second | |
182 // module. | |
183 vie_remb_->RemoveRembSender(&rtp_0); | |
184 vie_remb_->AddRembSender(&rtp_1); | |
185 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
186 | |
187 bitrate_estimate = bitrate_estimate - 100; | |
188 EXPECT_CALL(rtp_1, SetREMBData(bitrate_estimate, ssrcs)) | |
189 .Times(1); | |
190 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
191 | |
192 vie_remb_->RemoveReceiveChannel(&rtp_0); | |
193 vie_remb_->RemoveReceiveChannel(&rtp_1); | |
194 } | |
195 | |
196 TEST_F(ViERembTest, OnlyOneRembForDoubleProcess) { | |
197 MockRtpRtcp rtp; | |
198 unsigned int bitrate_estimate = 456; | |
199 unsigned int ssrc = 1234; | |
200 std::vector<unsigned int> ssrcs(&ssrc, &ssrc + 1); | |
201 | |
202 vie_remb_->AddReceiveChannel(&rtp); | |
203 vie_remb_->AddRembSender(&rtp); | |
204 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
205 // Call OnReceiveBitrateChanged twice to get a first estimate. | |
206 TickTime::AdvanceFakeClock(1000); | |
207 EXPECT_CALL(rtp, SetREMBData(_, _)) | |
208 .Times(1); | |
209 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
210 | |
211 // Lower the estimate, should trigger a call to SetREMBData right away. | |
212 bitrate_estimate = bitrate_estimate - 100; | |
213 EXPECT_CALL(rtp, SetREMBData(bitrate_estimate, ssrcs)) | |
214 .Times(1); | |
215 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
216 | |
217 // Call OnReceiveBitrateChanged again, this should not trigger a new callback. | |
218 EXPECT_CALL(rtp, SetREMBData(_, _)) | |
219 .Times(0); | |
220 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
221 vie_remb_->RemoveReceiveChannel(&rtp); | |
222 vie_remb_->RemoveRembSender(&rtp); | |
223 } | |
224 | |
225 // Only register receiving modules and make sure we fallback to trigger a REMB | |
226 // packet on this one. | |
227 TEST_F(ViERembTest, NoSendingRtpModule) { | |
228 MockRtpRtcp rtp; | |
229 vie_remb_->AddReceiveChannel(&rtp); | |
230 | |
231 unsigned int bitrate_estimate = 456; | |
232 unsigned int ssrc = 1234; | |
233 std::vector<unsigned int> ssrcs(&ssrc, &ssrc + 1); | |
234 | |
235 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
236 | |
237 // Call OnReceiveBitrateChanged twice to get a first estimate. | |
238 TickTime::AdvanceFakeClock(1000); | |
239 EXPECT_CALL(rtp, SetREMBData(_, _)) | |
240 .Times(1); | |
241 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
242 | |
243 // Lower the estimate to trigger a new packet REMB packet. | |
244 bitrate_estimate = bitrate_estimate - 100; | |
245 EXPECT_CALL(rtp, SetREMBData(_, _)) | |
246 .Times(1); | |
247 vie_remb_->OnReceiveBitrateChanged(ssrcs, bitrate_estimate); | |
248 } | |
249 | |
250 } // namespace webrtc | |
OLD | NEW |