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