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