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 "modules/remote_bitrate_estimator/overuse_detector.h"
12
13 #include <stdio.h>
14 #include <string.h>
15
16 #include <algorithm>
17 #include <cstdlib>
18 #include <memory>
19
20 #include "api/transport/field_trial_based_config.h"
21 #include "modules/remote_bitrate_estimator/inter_arrival.h"
22 #include "modules/remote_bitrate_estimator/overuse_estimator.h"
23 #include "rtc_base/random.h"
24 #include "test/field_trial.h"
25 #include "test/gtest.h"
26
27 namespace webrtc {
28 namespace testing {
29
30 const double kRtpTimestampToMs = 1.0 / 90.0;
31
32 class OveruseDetectorTest : public ::testing::Test {
33 public:
OveruseDetectorTest()34 OveruseDetectorTest()
35 : now_ms_(0),
36 receive_time_ms_(0),
37 rtp_timestamp_(10 * 90),
38 overuse_detector_(),
39 overuse_estimator_(new OveruseEstimator(options_)),
40 inter_arrival_(new InterArrival(5 * 90, kRtpTimestampToMs, true)),
41 random_(123456789) {}
42
43 protected:
SetUp()44 void SetUp() override {
45 overuse_detector_.reset(new OveruseDetector(&field_trials_));
46 }
47
Run100000Samples(int packets_per_frame,size_t packet_size,int mean_ms,int standard_deviation_ms)48 int Run100000Samples(int packets_per_frame,
49 size_t packet_size,
50 int mean_ms,
51 int standard_deviation_ms) {
52 int unique_overuse = 0;
53 int last_overuse = -1;
54 for (int i = 0; i < 100000; ++i) {
55 for (int j = 0; j < packets_per_frame; ++j) {
56 UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size);
57 }
58 rtp_timestamp_ += mean_ms * 90;
59 now_ms_ += mean_ms;
60 receive_time_ms_ = std::max<int64_t>(
61 receive_time_ms_,
62 now_ms_ + static_cast<int64_t>(
63 random_.Gaussian(0, standard_deviation_ms) + 0.5));
64 if (BandwidthUsage::kBwOverusing == overuse_detector_->State()) {
65 if (last_overuse + 1 != i) {
66 unique_overuse++;
67 }
68 last_overuse = i;
69 }
70 }
71 return unique_overuse;
72 }
73
RunUntilOveruse(int packets_per_frame,size_t packet_size,int mean_ms,int standard_deviation_ms,int drift_per_frame_ms)74 int RunUntilOveruse(int packets_per_frame,
75 size_t packet_size,
76 int mean_ms,
77 int standard_deviation_ms,
78 int drift_per_frame_ms) {
79 // Simulate a higher send pace, that is too high.
80 for (int i = 0; i < 1000; ++i) {
81 for (int j = 0; j < packets_per_frame; ++j) {
82 UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size);
83 }
84 rtp_timestamp_ += mean_ms * 90;
85 now_ms_ += mean_ms + drift_per_frame_ms;
86 receive_time_ms_ = std::max<int64_t>(
87 receive_time_ms_,
88 now_ms_ + static_cast<int64_t>(
89 random_.Gaussian(0, standard_deviation_ms) + 0.5));
90 if (BandwidthUsage::kBwOverusing == overuse_detector_->State()) {
91 return i + 1;
92 }
93 }
94 return -1;
95 }
96
UpdateDetector(uint32_t rtp_timestamp,int64_t receive_time_ms,size_t packet_size)97 void UpdateDetector(uint32_t rtp_timestamp,
98 int64_t receive_time_ms,
99 size_t packet_size) {
100 uint32_t timestamp_delta;
101 int64_t time_delta;
102 int size_delta;
103 if (inter_arrival_->ComputeDeltas(
104 rtp_timestamp, receive_time_ms, receive_time_ms, packet_size,
105 ×tamp_delta, &time_delta, &size_delta)) {
106 double timestamp_delta_ms = timestamp_delta / 90.0;
107 overuse_estimator_->Update(time_delta, timestamp_delta_ms, size_delta,
108 overuse_detector_->State(), receive_time_ms);
109 overuse_detector_->Detect(
110 overuse_estimator_->offset(), timestamp_delta_ms,
111 overuse_estimator_->num_of_deltas(), receive_time_ms);
112 }
113 }
114
115 const FieldTrialBasedConfig field_trials_;
116 int64_t now_ms_;
117 int64_t receive_time_ms_;
118 uint32_t rtp_timestamp_;
119 OverUseDetectorOptions options_;
120 std::unique_ptr<OveruseDetector> overuse_detector_;
121 std::unique_ptr<OveruseEstimator> overuse_estimator_;
122 std::unique_ptr<InterArrival> inter_arrival_;
123 Random random_;
124 };
125
TEST_F(OveruseDetectorTest,GaussianRandom)126 TEST_F(OveruseDetectorTest, GaussianRandom) {
127 int buckets[100];
128 memset(buckets, 0, sizeof(buckets));
129 for (int i = 0; i < 100000; ++i) {
130 int index = random_.Gaussian(49, 10);
131 if (index >= 0 && index < 100)
132 buckets[index]++;
133 }
134 for (int n = 0; n < 100; ++n) {
135 printf("Bucket n:%d, %d\n", n, buckets[n]);
136 }
137 }
138
TEST_F(OveruseDetectorTest,SimpleNonOveruse30fps)139 TEST_F(OveruseDetectorTest, SimpleNonOveruse30fps) {
140 size_t packet_size = 1200;
141 uint32_t frame_duration_ms = 33;
142 uint32_t rtp_timestamp = 10 * 90;
143
144 // No variance.
145 for (int i = 0; i < 1000; ++i) {
146 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
147 now_ms_ += frame_duration_ms;
148 rtp_timestamp += frame_duration_ms * 90;
149 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
150 }
151 }
152
153 // Roughly 1 Mbit/s
TEST_F(OveruseDetectorTest,SimpleNonOveruseWithReceiveVariance)154 TEST_F(OveruseDetectorTest, SimpleNonOveruseWithReceiveVariance) {
155 uint32_t frame_duration_ms = 10;
156 uint32_t rtp_timestamp = 10 * 90;
157 size_t packet_size = 1200;
158
159 for (int i = 0; i < 1000; ++i) {
160 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
161 rtp_timestamp += frame_duration_ms * 90;
162 if (i % 2) {
163 now_ms_ += frame_duration_ms - 5;
164 } else {
165 now_ms_ += frame_duration_ms + 5;
166 }
167 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
168 }
169 }
170
TEST_F(OveruseDetectorTest,SimpleNonOveruseWithRtpTimestampVariance)171 TEST_F(OveruseDetectorTest, SimpleNonOveruseWithRtpTimestampVariance) {
172 // Roughly 1 Mbit/s.
173 uint32_t frame_duration_ms = 10;
174 uint32_t rtp_timestamp = 10 * 90;
175 size_t packet_size = 1200;
176
177 for (int i = 0; i < 1000; ++i) {
178 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
179 now_ms_ += frame_duration_ms;
180 if (i % 2) {
181 rtp_timestamp += (frame_duration_ms - 5) * 90;
182 } else {
183 rtp_timestamp += (frame_duration_ms + 5) * 90;
184 }
185 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
186 }
187 }
188
TEST_F(OveruseDetectorTest,SimpleOveruse2000Kbit30fps)189 TEST_F(OveruseDetectorTest, SimpleOveruse2000Kbit30fps) {
190 size_t packet_size = 1200;
191 int packets_per_frame = 6;
192 int frame_duration_ms = 33;
193 int drift_per_frame_ms = 1;
194 int sigma_ms = 0; // No variance.
195 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
196 frame_duration_ms, sigma_ms);
197
198 EXPECT_EQ(0, unique_overuse);
199 int frames_until_overuse =
200 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
201 sigma_ms, drift_per_frame_ms);
202 EXPECT_EQ(7, frames_until_overuse);
203 }
204
TEST_F(OveruseDetectorTest,SimpleOveruse100kbit10fps)205 TEST_F(OveruseDetectorTest, SimpleOveruse100kbit10fps) {
206 size_t packet_size = 1200;
207 int packets_per_frame = 1;
208 int frame_duration_ms = 100;
209 int drift_per_frame_ms = 1;
210 int sigma_ms = 0; // No variance.
211 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
212 frame_duration_ms, sigma_ms);
213
214 EXPECT_EQ(0, unique_overuse);
215 int frames_until_overuse =
216 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
217 sigma_ms, drift_per_frame_ms);
218 EXPECT_EQ(7, frames_until_overuse);
219 }
220
TEST_F(OveruseDetectorTest,DISABLED_OveruseWithHighVariance100Kbit10fps)221 TEST_F(OveruseDetectorTest, DISABLED_OveruseWithHighVariance100Kbit10fps) {
222 uint32_t frame_duration_ms = 100;
223 uint32_t drift_per_frame_ms = 10;
224 uint32_t rtp_timestamp = frame_duration_ms * 90;
225 size_t packet_size = 1200;
226 int offset = 10;
227
228 // Run 1000 samples to reach steady state.
229 for (int i = 0; i < 1000; ++i) {
230 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
231 rtp_timestamp += frame_duration_ms * 90;
232 if (i % 2) {
233 offset = random_.Rand(0, 49);
234 now_ms_ += frame_duration_ms - offset;
235 } else {
236 now_ms_ += frame_duration_ms + offset;
237 }
238 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
239 }
240 // Simulate a higher send pace, that is too high.
241 // Above noise generate a standard deviation of approximately 28 ms.
242 // Total build up of 150 ms.
243 for (int j = 0; j < 15; ++j) {
244 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
245 now_ms_ += frame_duration_ms + drift_per_frame_ms;
246 rtp_timestamp += frame_duration_ms * 90;
247 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
248 }
249 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
250 EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_->State());
251 }
252
TEST_F(OveruseDetectorTest,DISABLED_OveruseWithLowVariance100Kbit10fps)253 TEST_F(OveruseDetectorTest, DISABLED_OveruseWithLowVariance100Kbit10fps) {
254 uint32_t frame_duration_ms = 100;
255 uint32_t drift_per_frame_ms = 1;
256 uint32_t rtp_timestamp = frame_duration_ms * 90;
257 size_t packet_size = 1200;
258 int offset = 10;
259
260 // Run 1000 samples to reach steady state.
261 for (int i = 0; i < 1000; ++i) {
262 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
263 rtp_timestamp += frame_duration_ms * 90;
264 if (i % 2) {
265 offset = random_.Rand(0, 1);
266 now_ms_ += frame_duration_ms - offset;
267 } else {
268 now_ms_ += frame_duration_ms + offset;
269 }
270 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
271 }
272 // Simulate a higher send pace, that is too high.
273 // Total build up of 6 ms.
274 for (int j = 0; j < 6; ++j) {
275 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
276 now_ms_ += frame_duration_ms + drift_per_frame_ms;
277 rtp_timestamp += frame_duration_ms * 90;
278 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
279 }
280 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
281 EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_->State());
282 }
283
TEST_F(OveruseDetectorTest,OveruseWithLowVariance2000Kbit30fps)284 TEST_F(OveruseDetectorTest, OveruseWithLowVariance2000Kbit30fps) {
285 uint32_t frame_duration_ms = 33;
286 uint32_t drift_per_frame_ms = 1;
287 uint32_t rtp_timestamp = frame_duration_ms * 90;
288 size_t packet_size = 1200;
289 int offset = 0;
290
291 // Run 1000 samples to reach steady state.
292 for (int i = 0; i < 1000; ++i) {
293 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
294 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
295 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
296 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
297 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
298 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
299 rtp_timestamp += frame_duration_ms * 90;
300 if (i % 2) {
301 offset = random_.Rand(0, 1);
302 now_ms_ += frame_duration_ms - offset;
303 } else {
304 now_ms_ += frame_duration_ms + offset;
305 }
306 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
307 }
308 // Simulate a higher send pace, that is too high.
309 // Total build up of 30 ms.
310 for (int j = 0; j < 3; ++j) {
311 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
312 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
313 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
314 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
315 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
316 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
317 now_ms_ += frame_duration_ms + drift_per_frame_ms * 6;
318 rtp_timestamp += frame_duration_ms * 90;
319 EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_->State());
320 }
321 UpdateDetector(rtp_timestamp, now_ms_, packet_size);
322 EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_->State());
323 }
324
325 #if defined(WEBRTC_ANDROID)
326 #define MAYBE_LowGaussianVariance30Kbit3fps \
327 DISABLED_LowGaussianVariance30Kbit3fps
328 #else
329 #define MAYBE_LowGaussianVariance30Kbit3fps LowGaussianVariance30Kbit3fps
330 #endif
TEST_F(OveruseDetectorTest,MAYBE_LowGaussianVariance30Kbit3fps)331 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance30Kbit3fps) {
332 size_t packet_size = 1200;
333 int packets_per_frame = 1;
334 int frame_duration_ms = 333;
335 int drift_per_frame_ms = 1;
336 int sigma_ms = 3;
337 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
338 frame_duration_ms, sigma_ms);
339 EXPECT_EQ(0, unique_overuse);
340 int frames_until_overuse =
341 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
342 sigma_ms, drift_per_frame_ms);
343 EXPECT_EQ(20, frames_until_overuse);
344 }
345
TEST_F(OveruseDetectorTest,LowGaussianVarianceFastDrift30Kbit3fps)346 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift30Kbit3fps) {
347 size_t packet_size = 1200;
348 int packets_per_frame = 1;
349 int frame_duration_ms = 333;
350 int drift_per_frame_ms = 100;
351 int sigma_ms = 3;
352 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
353 frame_duration_ms, sigma_ms);
354 EXPECT_EQ(0, unique_overuse);
355 int frames_until_overuse =
356 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
357 sigma_ms, drift_per_frame_ms);
358 EXPECT_EQ(4, frames_until_overuse);
359 }
360
TEST_F(OveruseDetectorTest,HighGaussianVariance30Kbit3fps)361 TEST_F(OveruseDetectorTest, HighGaussianVariance30Kbit3fps) {
362 size_t packet_size = 1200;
363 int packets_per_frame = 1;
364 int frame_duration_ms = 333;
365 int drift_per_frame_ms = 1;
366 int sigma_ms = 10;
367 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
368 frame_duration_ms, sigma_ms);
369 EXPECT_EQ(0, unique_overuse);
370 int frames_until_overuse =
371 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
372 sigma_ms, drift_per_frame_ms);
373 EXPECT_EQ(44, frames_until_overuse);
374 }
375
TEST_F(OveruseDetectorTest,HighGaussianVarianceFastDrift30Kbit3fps)376 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift30Kbit3fps) {
377 size_t packet_size = 1200;
378 int packets_per_frame = 1;
379 int frame_duration_ms = 333;
380 int drift_per_frame_ms = 100;
381 int sigma_ms = 10;
382 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
383 frame_duration_ms, sigma_ms);
384 EXPECT_EQ(0, unique_overuse);
385 int frames_until_overuse =
386 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
387 sigma_ms, drift_per_frame_ms);
388 EXPECT_EQ(4, frames_until_overuse);
389 }
390
391 #if defined(WEBRTC_ANDROID)
392 #define MAYBE_LowGaussianVariance100Kbit5fps \
393 DISABLED_LowGaussianVariance100Kbit5fps
394 #else
395 #define MAYBE_LowGaussianVariance100Kbit5fps LowGaussianVariance100Kbit5fps
396 #endif
TEST_F(OveruseDetectorTest,MAYBE_LowGaussianVariance100Kbit5fps)397 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance100Kbit5fps) {
398 size_t packet_size = 1200;
399 int packets_per_frame = 2;
400 int frame_duration_ms = 200;
401 int drift_per_frame_ms = 1;
402 int sigma_ms = 3;
403 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
404 frame_duration_ms, sigma_ms);
405 EXPECT_EQ(0, unique_overuse);
406 int frames_until_overuse =
407 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
408 sigma_ms, drift_per_frame_ms);
409 EXPECT_EQ(20, frames_until_overuse);
410 }
411
412 #if defined(WEBRTC_ANDROID)
413 #define MAYBE_HighGaussianVariance100Kbit5fps \
414 DISABLED_HighGaussianVariance100Kbit5fps
415 #else
416 #define MAYBE_HighGaussianVariance100Kbit5fps HighGaussianVariance100Kbit5fps
417 #endif
TEST_F(OveruseDetectorTest,MAYBE_HighGaussianVariance100Kbit5fps)418 TEST_F(OveruseDetectorTest, MAYBE_HighGaussianVariance100Kbit5fps) {
419 size_t packet_size = 1200;
420 int packets_per_frame = 2;
421 int frame_duration_ms = 200;
422 int drift_per_frame_ms = 1;
423 int sigma_ms = 10;
424 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
425 frame_duration_ms, sigma_ms);
426 EXPECT_EQ(0, unique_overuse);
427 int frames_until_overuse =
428 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
429 sigma_ms, drift_per_frame_ms);
430 EXPECT_EQ(44, frames_until_overuse);
431 }
432
433 #if defined(WEBRTC_ANDROID)
434 #define MAYBE_LowGaussianVariance100Kbit10fps \
435 DISABLED_LowGaussianVariance100Kbit10fps
436 #else
437 #define MAYBE_LowGaussianVariance100Kbit10fps LowGaussianVariance100Kbit10fps
438 #endif
TEST_F(OveruseDetectorTest,MAYBE_LowGaussianVariance100Kbit10fps)439 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance100Kbit10fps) {
440 size_t packet_size = 1200;
441 int packets_per_frame = 1;
442 int frame_duration_ms = 100;
443 int drift_per_frame_ms = 1;
444 int sigma_ms = 3;
445 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
446 frame_duration_ms, sigma_ms);
447 EXPECT_EQ(0, unique_overuse);
448 int frames_until_overuse =
449 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
450 sigma_ms, drift_per_frame_ms);
451 EXPECT_EQ(20, frames_until_overuse);
452 }
453
454 #if defined(WEBRTC_ANDROID)
455 #define MAYBE_HighGaussianVariance100Kbit10fps \
456 DISABLED_HighGaussianVariance100Kbit10fps
457 #else
458 #define MAYBE_HighGaussianVariance100Kbit10fps HighGaussianVariance100Kbit10fps
459 #endif
TEST_F(OveruseDetectorTest,MAYBE_HighGaussianVariance100Kbit10fps)460 TEST_F(OveruseDetectorTest, MAYBE_HighGaussianVariance100Kbit10fps) {
461 size_t packet_size = 1200;
462 int packets_per_frame = 1;
463 int frame_duration_ms = 100;
464 int drift_per_frame_ms = 1;
465 int sigma_ms = 10;
466 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
467 frame_duration_ms, sigma_ms);
468 EXPECT_EQ(0, unique_overuse);
469 int frames_until_overuse =
470 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
471 sigma_ms, drift_per_frame_ms);
472 EXPECT_EQ(44, frames_until_overuse);
473 }
474
475 #if defined(WEBRTC_ANDROID)
476 #define MAYBE_LowGaussianVariance300Kbit30fps \
477 DISABLED_LowGaussianVariance300Kbit30fps
478 #else
479 #define MAYBE_LowGaussianVariance300Kbit30fps LowGaussianVariance300Kbit30fps
480 #endif
TEST_F(OveruseDetectorTest,MAYBE_LowGaussianVariance300Kbit30fps)481 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance300Kbit30fps) {
482 size_t packet_size = 1200;
483 int packets_per_frame = 1;
484 int frame_duration_ms = 33;
485 int drift_per_frame_ms = 1;
486 int sigma_ms = 3;
487 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
488 frame_duration_ms, sigma_ms);
489 EXPECT_EQ(0, unique_overuse);
490 int frames_until_overuse =
491 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
492 sigma_ms, drift_per_frame_ms);
493 EXPECT_EQ(19, frames_until_overuse);
494 }
495
TEST_F(OveruseDetectorTest,LowGaussianVarianceFastDrift300Kbit30fps)496 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift300Kbit30fps) {
497 size_t packet_size = 1200;
498 int packets_per_frame = 1;
499 int frame_duration_ms = 33;
500 int drift_per_frame_ms = 10;
501 int sigma_ms = 3;
502 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
503 frame_duration_ms, sigma_ms);
504 EXPECT_EQ(0, unique_overuse);
505 int frames_until_overuse =
506 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
507 sigma_ms, drift_per_frame_ms);
508 EXPECT_EQ(5, frames_until_overuse);
509 }
510
TEST_F(OveruseDetectorTest,HighGaussianVariance300Kbit30fps)511 TEST_F(OveruseDetectorTest, HighGaussianVariance300Kbit30fps) {
512 size_t packet_size = 1200;
513 int packets_per_frame = 1;
514 int frame_duration_ms = 33;
515 int drift_per_frame_ms = 1;
516 int sigma_ms = 10;
517 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
518 frame_duration_ms, sigma_ms);
519 EXPECT_EQ(0, unique_overuse);
520 int frames_until_overuse =
521 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
522 sigma_ms, drift_per_frame_ms);
523 EXPECT_EQ(44, frames_until_overuse);
524 }
525
TEST_F(OveruseDetectorTest,HighGaussianVarianceFastDrift300Kbit30fps)526 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift300Kbit30fps) {
527 size_t packet_size = 1200;
528 int packets_per_frame = 1;
529 int frame_duration_ms = 33;
530 int drift_per_frame_ms = 10;
531 int sigma_ms = 10;
532 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
533 frame_duration_ms, sigma_ms);
534 EXPECT_EQ(0, unique_overuse);
535 int frames_until_overuse =
536 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
537 sigma_ms, drift_per_frame_ms);
538 EXPECT_EQ(10, frames_until_overuse);
539 }
540
541 #if defined(WEBRTC_ANDROID)
542 #define MAYBE_LowGaussianVariance1000Kbit30fps \
543 DISABLED_LowGaussianVariance1000Kbit30fps
544 #else
545 #define MAYBE_LowGaussianVariance1000Kbit30fps LowGaussianVariance1000Kbit30fps
546 #endif
TEST_F(OveruseDetectorTest,MAYBE_LowGaussianVariance1000Kbit30fps)547 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance1000Kbit30fps) {
548 size_t packet_size = 1200;
549 int packets_per_frame = 3;
550 int frame_duration_ms = 33;
551 int drift_per_frame_ms = 1;
552 int sigma_ms = 3;
553 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
554 frame_duration_ms, sigma_ms);
555 EXPECT_EQ(0, unique_overuse);
556 int frames_until_overuse =
557 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
558 sigma_ms, drift_per_frame_ms);
559 EXPECT_EQ(19, frames_until_overuse);
560 }
561
TEST_F(OveruseDetectorTest,LowGaussianVarianceFastDrift1000Kbit30fps)562 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift1000Kbit30fps) {
563 size_t packet_size = 1200;
564 int packets_per_frame = 3;
565 int frame_duration_ms = 33;
566 int drift_per_frame_ms = 10;
567 int sigma_ms = 3;
568 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
569 frame_duration_ms, sigma_ms);
570 EXPECT_EQ(0, unique_overuse);
571 int frames_until_overuse =
572 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
573 sigma_ms, drift_per_frame_ms);
574 EXPECT_EQ(5, frames_until_overuse);
575 }
576
TEST_F(OveruseDetectorTest,HighGaussianVariance1000Kbit30fps)577 TEST_F(OveruseDetectorTest, HighGaussianVariance1000Kbit30fps) {
578 size_t packet_size = 1200;
579 int packets_per_frame = 3;
580 int frame_duration_ms = 33;
581 int drift_per_frame_ms = 1;
582 int sigma_ms = 10;
583 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
584 frame_duration_ms, sigma_ms);
585 EXPECT_EQ(0, unique_overuse);
586 int frames_until_overuse =
587 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
588 sigma_ms, drift_per_frame_ms);
589 EXPECT_EQ(44, frames_until_overuse);
590 }
591
TEST_F(OveruseDetectorTest,HighGaussianVarianceFastDrift1000Kbit30fps)592 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift1000Kbit30fps) {
593 size_t packet_size = 1200;
594 int packets_per_frame = 3;
595 int frame_duration_ms = 33;
596 int drift_per_frame_ms = 10;
597 int sigma_ms = 10;
598 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
599 frame_duration_ms, sigma_ms);
600 EXPECT_EQ(0, unique_overuse);
601 int frames_until_overuse =
602 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
603 sigma_ms, drift_per_frame_ms);
604 EXPECT_EQ(10, frames_until_overuse);
605 }
606
607 #if defined(WEBRTC_ANDROID)
608 #define MAYBE_LowGaussianVariance2000Kbit30fps \
609 DISABLED_LowGaussianVariance2000Kbit30fps
610 #else
611 #define MAYBE_LowGaussianVariance2000Kbit30fps LowGaussianVariance2000Kbit30fps
612 #endif
TEST_F(OveruseDetectorTest,MAYBE_LowGaussianVariance2000Kbit30fps)613 TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance2000Kbit30fps) {
614 size_t packet_size = 1200;
615 int packets_per_frame = 6;
616 int frame_duration_ms = 33;
617 int drift_per_frame_ms = 1;
618 int sigma_ms = 3;
619 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
620 frame_duration_ms, sigma_ms);
621 EXPECT_EQ(0, unique_overuse);
622 int frames_until_overuse =
623 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
624 sigma_ms, drift_per_frame_ms);
625 EXPECT_EQ(19, frames_until_overuse);
626 }
627
TEST_F(OveruseDetectorTest,LowGaussianVarianceFastDrift2000Kbit30fps)628 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift2000Kbit30fps) {
629 size_t packet_size = 1200;
630 int packets_per_frame = 6;
631 int frame_duration_ms = 33;
632 int drift_per_frame_ms = 10;
633 int sigma_ms = 3;
634 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
635 frame_duration_ms, sigma_ms);
636 EXPECT_EQ(0, unique_overuse);
637 int frames_until_overuse =
638 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
639 sigma_ms, drift_per_frame_ms);
640 EXPECT_EQ(5, frames_until_overuse);
641 }
642
TEST_F(OveruseDetectorTest,HighGaussianVariance2000Kbit30fps)643 TEST_F(OveruseDetectorTest, HighGaussianVariance2000Kbit30fps) {
644 size_t packet_size = 1200;
645 int packets_per_frame = 6;
646 int frame_duration_ms = 33;
647 int drift_per_frame_ms = 1;
648 int sigma_ms = 10;
649 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
650 frame_duration_ms, sigma_ms);
651 EXPECT_EQ(0, unique_overuse);
652 int frames_until_overuse =
653 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
654 sigma_ms, drift_per_frame_ms);
655 EXPECT_EQ(44, frames_until_overuse);
656 }
657
TEST_F(OveruseDetectorTest,HighGaussianVarianceFastDrift2000Kbit30fps)658 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift2000Kbit30fps) {
659 size_t packet_size = 1200;
660 int packets_per_frame = 6;
661 int frame_duration_ms = 33;
662 int drift_per_frame_ms = 10;
663 int sigma_ms = 10;
664 int unique_overuse = Run100000Samples(packets_per_frame, packet_size,
665 frame_duration_ms, sigma_ms);
666 EXPECT_EQ(0, unique_overuse);
667 int frames_until_overuse =
668 RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms,
669 sigma_ms, drift_per_frame_ms);
670 EXPECT_EQ(10, frames_until_overuse);
671 }
672
673 class OveruseDetectorExperimentTest : public OveruseDetectorTest {
674 public:
OveruseDetectorExperimentTest()675 OveruseDetectorExperimentTest()
676 : override_field_trials_(
677 "WebRTC-AdaptiveBweThreshold/Enabled-0.01,0.00018/") {}
678
679 protected:
SetUp()680 void SetUp() override {
681 overuse_detector_.reset(new OveruseDetector(&field_trials_));
682 }
683
684 test::ScopedFieldTrials override_field_trials_;
685 const FieldTrialBasedConfig field_trials_;
686 };
687
TEST_F(OveruseDetectorExperimentTest,ThresholdAdapts)688 TEST_F(OveruseDetectorExperimentTest, ThresholdAdapts) {
689 const double kOffset = 0.21;
690 double kTsDelta = 3000.0;
691 int64_t now_ms = 0;
692 int num_deltas = 60;
693 const int kBatchLength = 10;
694
695 // Pass in a positive offset and verify it triggers overuse.
696 bool overuse_detected = false;
697 for (int i = 0; i < kBatchLength; ++i) {
698 BandwidthUsage overuse_state =
699 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
700 if (overuse_state == BandwidthUsage::kBwOverusing) {
701 overuse_detected = true;
702 }
703 ++num_deltas;
704 now_ms += 5;
705 }
706 EXPECT_TRUE(overuse_detected);
707
708 // Force the threshold to increase by passing in a higher offset.
709 overuse_detected = false;
710 for (int i = 0; i < kBatchLength; ++i) {
711 BandwidthUsage overuse_state =
712 overuse_detector_->Detect(1.1 * kOffset, kTsDelta, num_deltas, now_ms);
713 if (overuse_state == BandwidthUsage::kBwOverusing) {
714 overuse_detected = true;
715 }
716 ++num_deltas;
717 now_ms += 5;
718 }
719 EXPECT_TRUE(overuse_detected);
720
721 // Verify that the same offset as before no longer triggers overuse.
722 overuse_detected = false;
723 for (int i = 0; i < kBatchLength; ++i) {
724 BandwidthUsage overuse_state =
725 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
726 if (overuse_state == BandwidthUsage::kBwOverusing) {
727 overuse_detected = true;
728 }
729 ++num_deltas;
730 now_ms += 5;
731 }
732 EXPECT_FALSE(overuse_detected);
733
734 // Pass in a low offset to make the threshold adapt down.
735 for (int i = 0; i < 15 * kBatchLength; ++i) {
736 BandwidthUsage overuse_state =
737 overuse_detector_->Detect(0.7 * kOffset, kTsDelta, num_deltas, now_ms);
738 if (overuse_state == BandwidthUsage::kBwOverusing) {
739 overuse_detected = true;
740 }
741 ++num_deltas;
742 now_ms += 5;
743 }
744 EXPECT_FALSE(overuse_detected);
745
746 // Make sure the original offset now again triggers overuse.
747 for (int i = 0; i < kBatchLength; ++i) {
748 BandwidthUsage overuse_state =
749 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
750 if (overuse_state == BandwidthUsage::kBwOverusing) {
751 overuse_detected = true;
752 }
753 ++num_deltas;
754 now_ms += 5;
755 }
756 EXPECT_TRUE(overuse_detected);
757 }
758
TEST_F(OveruseDetectorExperimentTest,DoesntAdaptToSpikes)759 TEST_F(OveruseDetectorExperimentTest, DoesntAdaptToSpikes) {
760 const double kOffset = 1.0;
761 const double kLargeOffset = 20.0;
762 double kTsDelta = 3000.0;
763 int64_t now_ms = 0;
764 int num_deltas = 60;
765 const int kBatchLength = 10;
766 const int kShortBatchLength = 3;
767
768 // Pass in a positive offset and verify it triggers overuse.
769 bool overuse_detected = false;
770 for (int i = 0; i < kBatchLength; ++i) {
771 BandwidthUsage overuse_state =
772 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
773 if (overuse_state == BandwidthUsage::kBwOverusing) {
774 overuse_detected = true;
775 }
776 ++num_deltas;
777 now_ms += 5;
778 }
779
780 // Pass in a large offset. This shouldn't have a too big impact on the
781 // threshold, but still trigger an overuse.
782 now_ms += 100;
783 overuse_detected = false;
784 for (int i = 0; i < kShortBatchLength; ++i) {
785 BandwidthUsage overuse_state =
786 overuse_detector_->Detect(kLargeOffset, kTsDelta, num_deltas, now_ms);
787 if (overuse_state == BandwidthUsage::kBwOverusing) {
788 overuse_detected = true;
789 }
790 ++num_deltas;
791 now_ms += 5;
792 }
793 EXPECT_TRUE(overuse_detected);
794
795 // Pass in a positive normal offset and verify it still triggers.
796 overuse_detected = false;
797 for (int i = 0; i < kBatchLength; ++i) {
798 BandwidthUsage overuse_state =
799 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms);
800 if (overuse_state == BandwidthUsage::kBwOverusing) {
801 overuse_detected = true;
802 }
803 ++num_deltas;
804 now_ms += 5;
805 }
806 EXPECT_TRUE(overuse_detected);
807 }
808 } // namespace testing
809 } // namespace webrtc
810