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