OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 #include "webrtc/modules/congestion_controller/delay_based_bwe_unittest_helper.h
" | 10 #include "webrtc/modules/congestion_controller/delay_based_bwe_unittest_helper.h
" |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
143 packet.arrival_time_ms = prev_arrival_time_us_ / 1000; | 143 packet.arrival_time_ms = prev_arrival_time_us_ / 1000; |
144 ++i; | 144 ++i; |
145 } | 145 } |
146 it = std::min_element(streams_.begin(), streams_.end(), RtpStream::Compare); | 146 it = std::min_element(streams_.begin(), streams_.end(), RtpStream::Compare); |
147 return std::max((*it)->next_rtp_time(), time_now_us); | 147 return std::max((*it)->next_rtp_time(), time_now_us); |
148 } | 148 } |
149 } // namespace test | 149 } // namespace test |
150 | 150 |
151 DelayBasedBweTest::DelayBasedBweTest() | 151 DelayBasedBweTest::DelayBasedBweTest() |
152 : clock_(100000000), | 152 : clock_(100000000), |
153 bitrate_estimator_(&clock_), | 153 bitrate_estimator_(new DelayBasedBwe(&clock_)), |
154 stream_generator_(new test::StreamGenerator(1e6, // Capacity. | 154 stream_generator_(new test::StreamGenerator(1e6, // Capacity. |
155 clock_.TimeInMicroseconds())), | 155 clock_.TimeInMicroseconds())), |
156 arrival_time_offset_ms_(0) {} | 156 arrival_time_offset_ms_(0), |
| 157 first_update_(true) {} |
157 | 158 |
158 DelayBasedBweTest::~DelayBasedBweTest() {} | 159 DelayBasedBweTest::~DelayBasedBweTest() {} |
159 | 160 |
160 void DelayBasedBweTest::AddDefaultStream() { | 161 void DelayBasedBweTest::AddDefaultStream() { |
161 stream_generator_->AddStream(new test::RtpStream(30, 3e5)); | 162 stream_generator_->AddStream(new test::RtpStream(30, 3e5)); |
162 } | 163 } |
163 | 164 |
164 const uint32_t DelayBasedBweTest::kDefaultSsrc = 0; | 165 const uint32_t DelayBasedBweTest::kDefaultSsrc = 0; |
165 | 166 |
166 void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms, | 167 void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms, |
167 int64_t send_time_ms, | 168 int64_t send_time_ms, |
168 uint16_t sequence_number, | 169 uint16_t sequence_number, |
169 size_t payload_size) { | 170 size_t payload_size) { |
170 IncomingFeedback(arrival_time_ms, send_time_ms, sequence_number, payload_size, | 171 IncomingFeedback(arrival_time_ms, send_time_ms, sequence_number, payload_size, |
171 PacketInfo::kNotAProbe); | 172 PacketInfo::kNotAProbe); |
172 } | 173 } |
173 | 174 |
174 void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms, | 175 void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms, |
175 int64_t send_time_ms, | 176 int64_t send_time_ms, |
176 uint16_t sequence_number, | 177 uint16_t sequence_number, |
177 size_t payload_size, | 178 size_t payload_size, |
178 int probe_cluster_id) { | 179 int probe_cluster_id) { |
179 RTC_CHECK_GE(arrival_time_ms + arrival_time_offset_ms_, 0); | 180 RTC_CHECK_GE(arrival_time_ms + arrival_time_offset_ms_, 0); |
180 PacketInfo packet(arrival_time_ms + arrival_time_offset_ms_, send_time_ms, | 181 PacketInfo packet(arrival_time_ms + arrival_time_offset_ms_, send_time_ms, |
181 sequence_number, payload_size, probe_cluster_id); | 182 sequence_number, payload_size, probe_cluster_id); |
182 std::vector<PacketInfo> packets; | 183 std::vector<PacketInfo> packets; |
183 packets.push_back(packet); | 184 packets.push_back(packet); |
184 DelayBasedBwe::Result result = | 185 DelayBasedBwe::Result result = |
185 bitrate_estimator_.IncomingPacketFeedbackVector(packets); | 186 bitrate_estimator_->IncomingPacketFeedbackVector(packets); |
186 const uint32_t kDummySsrc = 0; | 187 const uint32_t kDummySsrc = 0; |
187 if (result.updated) { | 188 if (result.updated) { |
188 bitrate_observer_.OnReceiveBitrateChanged({kDummySsrc}, | 189 bitrate_observer_.OnReceiveBitrateChanged({kDummySsrc}, |
189 result.target_bitrate_bps); | 190 result.target_bitrate_bps); |
190 } | 191 } |
191 } | 192 } |
192 | 193 |
193 // Generates a frame of packets belonging to a stream at a given bitrate and | 194 // Generates a frame of packets belonging to a stream at a given bitrate and |
194 // with a given ssrc. The stream is pushed through a very simple simulated | 195 // with a given ssrc. The stream is pushed through a very simple simulated |
195 // network, and is then given to the receive-side bandwidth estimator. | 196 // network, and is then given to the receive-side bandwidth estimator. |
(...skipping 11 matching lines...) Expand all Loading... |
207 | 208 |
208 bool overuse = false; | 209 bool overuse = false; |
209 bitrate_observer_.Reset(); | 210 bitrate_observer_.Reset(); |
210 clock_.AdvanceTimeMicroseconds(1000 * packets.back().arrival_time_ms - | 211 clock_.AdvanceTimeMicroseconds(1000 * packets.back().arrival_time_ms - |
211 clock_.TimeInMicroseconds()); | 212 clock_.TimeInMicroseconds()); |
212 for (auto& packet : packets) { | 213 for (auto& packet : packets) { |
213 RTC_CHECK_GE(packet.arrival_time_ms + arrival_time_offset_ms_, 0); | 214 RTC_CHECK_GE(packet.arrival_time_ms + arrival_time_offset_ms_, 0); |
214 packet.arrival_time_ms += arrival_time_offset_ms_; | 215 packet.arrival_time_ms += arrival_time_offset_ms_; |
215 } | 216 } |
216 DelayBasedBwe::Result result = | 217 DelayBasedBwe::Result result = |
217 bitrate_estimator_.IncomingPacketFeedbackVector(packets); | 218 bitrate_estimator_->IncomingPacketFeedbackVector(packets); |
218 const uint32_t kDummySsrc = 0; | 219 const uint32_t kDummySsrc = 0; |
219 if (result.updated) { | 220 if (result.updated) { |
220 bitrate_observer_.OnReceiveBitrateChanged({kDummySsrc}, | 221 bitrate_observer_.OnReceiveBitrateChanged({kDummySsrc}, |
221 result.target_bitrate_bps); | 222 result.target_bitrate_bps); |
222 if (result.target_bitrate_bps < bitrate_bps) | 223 if (!first_update_ && result.target_bitrate_bps < bitrate_bps) |
223 overuse = true; | 224 overuse = true; |
| 225 first_update_ = false; |
224 } | 226 } |
225 | 227 |
226 clock_.AdvanceTimeMicroseconds(next_time_us - clock_.TimeInMicroseconds()); | 228 clock_.AdvanceTimeMicroseconds(next_time_us - clock_.TimeInMicroseconds()); |
227 return overuse; | 229 return overuse; |
228 } | 230 } |
229 | 231 |
230 // Run the bandwidth estimator with a stream of |number_of_frames| frames, or | 232 // Run the bandwidth estimator with a stream of |number_of_frames| frames, or |
231 // until it reaches |target_bitrate|. | 233 // until it reaches |target_bitrate|. |
232 // Can for instance be used to run the estimator for some time to get it | 234 // Can for instance be used to run the estimator for some time to get it |
233 // into a steady state. | 235 // into a steady state. |
(...skipping 26 matching lines...) Expand all Loading... |
260 } | 262 } |
261 | 263 |
262 void DelayBasedBweTest::InitialBehaviorTestHelper( | 264 void DelayBasedBweTest::InitialBehaviorTestHelper( |
263 uint32_t expected_converge_bitrate) { | 265 uint32_t expected_converge_bitrate) { |
264 const int kFramerate = 50; // 50 fps to avoid rounding errors. | 266 const int kFramerate = 50; // 50 fps to avoid rounding errors. |
265 const int kFrameIntervalMs = 1000 / kFramerate; | 267 const int kFrameIntervalMs = 1000 / kFramerate; |
266 uint32_t bitrate_bps = 0; | 268 uint32_t bitrate_bps = 0; |
267 int64_t send_time_ms = 0; | 269 int64_t send_time_ms = 0; |
268 uint16_t sequence_number = 0; | 270 uint16_t sequence_number = 0; |
269 std::vector<uint32_t> ssrcs; | 271 std::vector<uint32_t> ssrcs; |
270 EXPECT_FALSE(bitrate_estimator_.LatestEstimate(&ssrcs, &bitrate_bps)); | 272 EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); |
271 EXPECT_EQ(0u, ssrcs.size()); | 273 EXPECT_EQ(0u, ssrcs.size()); |
272 clock_.AdvanceTimeMilliseconds(1000); | 274 clock_.AdvanceTimeMilliseconds(1000); |
273 EXPECT_FALSE(bitrate_estimator_.LatestEstimate(&ssrcs, &bitrate_bps)); | 275 EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); |
274 EXPECT_FALSE(bitrate_observer_.updated()); | 276 EXPECT_FALSE(bitrate_observer_.updated()); |
275 bitrate_observer_.Reset(); | 277 bitrate_observer_.Reset(); |
276 clock_.AdvanceTimeMilliseconds(1000); | 278 clock_.AdvanceTimeMilliseconds(1000); |
277 // Inserting packets for 5 seconds to get a valid estimate. | 279 // Inserting packets for 5 seconds to get a valid estimate. |
278 for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) { | 280 for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) { |
279 // NOTE!!! If the following line is moved under the if case then this test | 281 // NOTE!!! If the following line is moved under the if case then this test |
280 // wont work on windows realease bots. | 282 // wont work on windows realease bots. |
281 int cluster_id = i < kInitialProbingPackets ? 0 : PacketInfo::kNotAProbe; | 283 int cluster_id = i < kInitialProbingPackets ? 0 : PacketInfo::kNotAProbe; |
282 | 284 |
283 if (i == kNumInitialPackets) { | 285 if (i == kNumInitialPackets) { |
284 EXPECT_FALSE(bitrate_estimator_.LatestEstimate(&ssrcs, &bitrate_bps)); | 286 EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); |
285 EXPECT_EQ(0u, ssrcs.size()); | 287 EXPECT_EQ(0u, ssrcs.size()); |
286 EXPECT_FALSE(bitrate_observer_.updated()); | 288 EXPECT_FALSE(bitrate_observer_.updated()); |
287 bitrate_observer_.Reset(); | 289 bitrate_observer_.Reset(); |
288 } | 290 } |
289 IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms, | 291 IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms, |
290 sequence_number++, kMtu, cluster_id); | 292 sequence_number++, kMtu, cluster_id); |
291 clock_.AdvanceTimeMilliseconds(1000 / kFramerate); | 293 clock_.AdvanceTimeMilliseconds(1000 / kFramerate); |
292 send_time_ms += kFrameIntervalMs; | 294 send_time_ms += kFrameIntervalMs; |
293 } | 295 } |
294 EXPECT_TRUE(bitrate_estimator_.LatestEstimate(&ssrcs, &bitrate_bps)); | 296 EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); |
295 ASSERT_EQ(1u, ssrcs.size()); | 297 ASSERT_EQ(1u, ssrcs.size()); |
296 EXPECT_EQ(kDefaultSsrc, ssrcs.front()); | 298 EXPECT_EQ(kDefaultSsrc, ssrcs.front()); |
297 EXPECT_NEAR(expected_converge_bitrate, bitrate_bps, kAcceptedBitrateErrorBps); | 299 EXPECT_NEAR(expected_converge_bitrate, bitrate_bps, kAcceptedBitrateErrorBps); |
298 EXPECT_TRUE(bitrate_observer_.updated()); | 300 EXPECT_TRUE(bitrate_observer_.updated()); |
299 bitrate_observer_.Reset(); | 301 bitrate_observer_.Reset(); |
300 EXPECT_EQ(bitrate_observer_.latest_bitrate(), bitrate_bps); | 302 EXPECT_EQ(bitrate_observer_.latest_bitrate(), bitrate_bps); |
301 } | 303 } |
302 | 304 |
303 void DelayBasedBweTest::RateIncreaseReorderingTestHelper( | 305 void DelayBasedBweTest::RateIncreaseReorderingTestHelper( |
304 uint32_t expected_bitrate_bps) { | 306 uint32_t expected_bitrate_bps) { |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
357 bool overuse = GenerateAndProcessFrame(kDefaultSsrc, bitrate_bps); | 359 bool overuse = GenerateAndProcessFrame(kDefaultSsrc, bitrate_bps); |
358 if (overuse) { | 360 if (overuse) { |
359 EXPECT_GT(bitrate_observer_.latest_bitrate(), bitrate_bps); | 361 EXPECT_GT(bitrate_observer_.latest_bitrate(), bitrate_bps); |
360 bitrate_bps = bitrate_observer_.latest_bitrate(); | 362 bitrate_bps = bitrate_observer_.latest_bitrate(); |
361 bitrate_observer_.Reset(); | 363 bitrate_observer_.Reset(); |
362 } else if (bitrate_observer_.updated()) { | 364 } else if (bitrate_observer_.updated()) { |
363 bitrate_bps = bitrate_observer_.latest_bitrate(); | 365 bitrate_bps = bitrate_observer_.latest_bitrate(); |
364 bitrate_observer_.Reset(); | 366 bitrate_observer_.Reset(); |
365 } | 367 } |
366 ++iterations; | 368 ++iterations; |
367 // ASSERT_LE(iterations, expected_iterations); | |
368 } | 369 } |
369 ASSERT_EQ(expected_iterations, iterations); | 370 ASSERT_EQ(expected_iterations, iterations); |
370 } | 371 } |
371 | 372 |
372 void DelayBasedBweTest::CapacityDropTestHelper( | 373 void DelayBasedBweTest::CapacityDropTestHelper( |
373 int number_of_streams, | 374 int number_of_streams, |
374 bool wrap_time_stamp, | 375 bool wrap_time_stamp, |
375 uint32_t expected_bitrate_drop_delta, | 376 uint32_t expected_bitrate_drop_delta, |
376 int64_t receiver_clock_offset_change_ms) { | 377 int64_t receiver_clock_offset_change_ms) { |
377 const int kFramerate = 30; | 378 const int kFramerate = 30; |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
476 uint16_t sequence_number = 0; | 477 uint16_t sequence_number = 0; |
477 | 478 |
478 for (size_t i = 0; i < 3000; ++i) { | 479 for (size_t i = 0; i < 3000; ++i) { |
479 IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms, | 480 IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms, |
480 sequence_number++, 1000); | 481 sequence_number++, 1000); |
481 clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); | 482 clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
482 send_time_ms += kFrameIntervalMs; | 483 send_time_ms += kFrameIntervalMs; |
483 } | 484 } |
484 uint32_t bitrate_before = 0; | 485 uint32_t bitrate_before = 0; |
485 std::vector<uint32_t> ssrcs; | 486 std::vector<uint32_t> ssrcs; |
486 bitrate_estimator_.LatestEstimate(&ssrcs, &bitrate_before); | 487 bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_before); |
487 | 488 |
488 clock_.AdvanceTimeMilliseconds(silence_time_s * 1000); | 489 clock_.AdvanceTimeMilliseconds(silence_time_s * 1000); |
489 send_time_ms += silence_time_s * 1000; | 490 send_time_ms += silence_time_s * 1000; |
490 | 491 |
491 for (size_t i = 0; i < 21; ++i) { | 492 for (size_t i = 0; i < 22; ++i) { |
492 IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms, | 493 IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms, |
493 sequence_number++, 1000); | 494 sequence_number++, 1000); |
494 clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs); | 495 clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs); |
495 send_time_ms += kFrameIntervalMs; | 496 send_time_ms += kFrameIntervalMs; |
496 } | 497 } |
497 uint32_t bitrate_after = 0; | 498 uint32_t bitrate_after = 0; |
498 bitrate_estimator_.LatestEstimate(&ssrcs, &bitrate_after); | 499 bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_after); |
499 EXPECT_LT(bitrate_after, bitrate_before); | 500 EXPECT_LT(bitrate_after, bitrate_before); |
500 } | 501 } |
501 } // namespace webrtc | 502 } // namespace webrtc |
OLD | NEW |