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             &timestamp_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