OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <math.h> | 11 #include <math.h> |
12 #include <cmath> | 12 #include <cmath> |
13 #include <cstdlib> | 13 #include <cstdlib> |
14 | 14 |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 | 16 |
17 #include "webrtc/base/scoped_ptr.h" | 17 #include "webrtc/base/scoped_ptr.h" |
18 #include "webrtc/common_types.h" | 18 #include "webrtc/common_types.h" |
19 #include "webrtc/modules/remote_bitrate_estimator/inter_arrival.h" | 19 #include "webrtc/modules/remote_bitrate_estimator/inter_arrival.h" |
20 #include "webrtc/modules/remote_bitrate_estimator/overuse_detector.h" | 20 #include "webrtc/modules/remote_bitrate_estimator/overuse_detector.h" |
21 #include "webrtc/modules/remote_bitrate_estimator/overuse_estimator.h" | 21 #include "webrtc/modules/remote_bitrate_estimator/overuse_estimator.h" |
| 22 #include "webrtc/modules/remote_bitrate_estimator/rate_statistics.h" |
| 23 #include "webrtc/modules/remote_bitrate_estimator/test/random.h" |
22 #include "webrtc/test/testsupport/gtest_disable.h" | 24 #include "webrtc/test/testsupport/gtest_disable.h" |
23 | 25 |
24 namespace webrtc { | 26 namespace webrtc { |
25 namespace testing { | 27 namespace testing { |
26 | 28 |
27 const double kRtpTimestampToMs = 1.0 / 90.0; | 29 const double kRtpTimestampToMs = 1.0 / 90.0; |
28 | 30 |
29 class OveruseDetectorTest : public ::testing::Test { | 31 class OveruseDetectorTest : public ::testing::Test { |
| 32 public: |
| 33 OveruseDetectorTest() : random_(1234) {} |
| 34 |
30 protected: | 35 protected: |
31 void SetUp() { | 36 void SetUp() { |
32 srand(1234); | |
33 now_ms_ = 0; | 37 now_ms_ = 0; |
34 receive_time_ms_ = 0; | 38 receive_time_ms_ = 0; |
35 rtp_timestamp_ = 10 * 90; | 39 rtp_timestamp_ = 10 * 90; |
36 overuse_detector_.reset(new OveruseDetector(options_)); | 40 overuse_detector_.reset(new OveruseDetector(options_)); |
37 overuse_estimator_.reset(new OveruseEstimator(options_)); | 41 overuse_estimator_.reset(new OveruseEstimator(options_)); |
38 inter_arrival_.reset(new InterArrival(5 * 90, kRtpTimestampToMs, true)); | 42 inter_arrival_.reset(new InterArrival(5 * 90, kRtpTimestampToMs, true)); |
39 } | 43 } |
40 // Normal Distribution. | |
41 #define PI 3.14159265 | |
42 int GaussianRandom(int mean_ms, int standard_deviation_ms) { | |
43 // Creating a Normal distribution variable from two independent uniform | |
44 // variables based on the Box-Muller transform. | |
45 double uniform1 = (std::rand() + 1.0) / (RAND_MAX + 1.0); | |
46 double uniform2 = (std::rand() + 1.0) / (RAND_MAX + 1.0); | |
47 return static_cast<int>(mean_ms + standard_deviation_ms * | |
48 sqrt(-2 * log(uniform1)) * cos(2 * PI * uniform2)); | |
49 } | |
50 | 44 |
51 int Run100000Samples(int packets_per_frame, size_t packet_size, int mean_ms, | 45 int Run100000Samples(int packets_per_frame, size_t packet_size, int mean_ms, |
52 int standard_deviation_ms) { | 46 int standard_deviation_ms) { |
53 int unique_overuse = 0; | 47 int unique_overuse = 0; |
54 int last_overuse = -1; | 48 int last_overuse = -1; |
55 for (int i = 0; i < 100000; ++i) { | 49 for (int i = 0; i < 100000; ++i) { |
56 for (int j = 0; j < packets_per_frame; ++j) { | 50 for (int j = 0; j < packets_per_frame; ++j) { |
57 UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size); | 51 UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size); |
58 } | 52 } |
59 rtp_timestamp_ += mean_ms * 90; | 53 rtp_timestamp_ += mean_ms * 90; |
60 now_ms_ += mean_ms; | 54 now_ms_ += mean_ms; |
61 receive_time_ms_ = std::max(receive_time_ms_, | 55 receive_time_ms_ = |
62 now_ms_ + GaussianRandom(0, standard_deviation_ms)); | 56 std::max(receive_time_ms_, |
| 57 now_ms_ + random_.Gaussian(0, standard_deviation_ms)); |
63 if (kBwOverusing == overuse_detector_->State()) { | 58 if (kBwOverusing == overuse_detector_->State()) { |
64 if (last_overuse + 1 != i) { | 59 if (last_overuse + 1 != i) { |
65 unique_overuse++; | 60 unique_overuse++; |
66 } | 61 } |
67 last_overuse = i; | 62 last_overuse = i; |
68 } | 63 } |
69 } | 64 } |
70 return unique_overuse; | 65 return unique_overuse; |
71 } | 66 } |
72 | 67 |
73 int RunUntilOveruse(int packets_per_frame, size_t packet_size, int mean_ms, | 68 int RunUntilOveruse(int packets_per_frame, size_t packet_size, int mean_ms, |
74 int standard_deviation_ms, int drift_per_frame_ms) { | 69 int standard_deviation_ms, int drift_per_frame_ms) { |
75 // Simulate a higher send pace, that is too high. | 70 // Simulate a higher send pace, that is too high. |
76 for (int i = 0; i < 1000; ++i) { | 71 for (int i = 0; i < 1000; ++i) { |
77 for (int j = 0; j < packets_per_frame; ++j) { | 72 for (int j = 0; j < packets_per_frame; ++j) { |
78 UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size); | 73 UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size); |
79 } | 74 } |
80 rtp_timestamp_ += mean_ms * 90; | 75 rtp_timestamp_ += mean_ms * 90; |
81 now_ms_ += mean_ms + drift_per_frame_ms; | 76 now_ms_ += mean_ms + drift_per_frame_ms; |
82 receive_time_ms_ = std::max(receive_time_ms_, | 77 receive_time_ms_ = |
83 now_ms_ + GaussianRandom(0, standard_deviation_ms)); | 78 std::max(receive_time_ms_, |
| 79 now_ms_ + random_.Gaussian(0, standard_deviation_ms)); |
84 if (kBwOverusing == overuse_detector_->State()) { | 80 if (kBwOverusing == overuse_detector_->State()) { |
85 return i + 1; | 81 return i + 1; |
86 } | 82 } |
87 } | 83 } |
88 return -1; | 84 return -1; |
89 } | 85 } |
90 | 86 |
91 void UpdateDetector(uint32_t rtp_timestamp, int64_t receive_time_ms, | 87 void UpdateDetector(uint32_t rtp_timestamp, int64_t receive_time_ms, |
92 size_t packet_size) { | 88 size_t packet_size) { |
93 uint32_t timestamp_delta; | 89 uint32_t timestamp_delta; |
94 int64_t time_delta; | 90 int64_t time_delta; |
95 int size_delta; | 91 int size_delta; |
96 if (inter_arrival_->ComputeDeltas(rtp_timestamp, | 92 if (inter_arrival_->ComputeDeltas(rtp_timestamp, |
97 receive_time_ms, | 93 receive_time_ms, |
98 packet_size, | 94 packet_size, |
99 ×tamp_delta, | 95 ×tamp_delta, |
100 &time_delta, | 96 &time_delta, |
101 &size_delta)) { | 97 &size_delta)) { |
102 double timestamp_delta_ms = timestamp_delta / 90.0; | 98 double timestamp_delta_ms = timestamp_delta / 90.0; |
103 overuse_estimator_->Update(time_delta, timestamp_delta_ms, size_delta, | 99 overuse_estimator_->Update(time_delta, timestamp_delta_ms, size_delta, |
104 overuse_detector_->State()); | 100 overuse_detector_->State()); |
105 overuse_detector_->Detect(overuse_estimator_->offset(), | 101 overuse_detector_->Detect( |
106 timestamp_delta_ms, | 102 overuse_estimator_->offset(), timestamp_delta_ms, |
107 overuse_estimator_->num_of_deltas(), 0); | 103 overuse_estimator_->num_of_deltas(), receive_time_ms); |
108 } | 104 } |
109 } | 105 } |
110 | 106 |
111 int64_t now_ms_; | 107 int64_t now_ms_; |
112 int64_t receive_time_ms_; | 108 int64_t receive_time_ms_; |
113 uint32_t rtp_timestamp_; | 109 uint32_t rtp_timestamp_; |
114 OverUseDetectorOptions options_; | 110 OverUseDetectorOptions options_; |
115 rtc::scoped_ptr<OveruseDetector> overuse_detector_; | 111 rtc::scoped_ptr<OveruseDetector> overuse_detector_; |
116 rtc::scoped_ptr<OveruseEstimator> overuse_estimator_; | 112 rtc::scoped_ptr<OveruseEstimator> overuse_estimator_; |
117 rtc::scoped_ptr<InterArrival> inter_arrival_; | 113 rtc::scoped_ptr<InterArrival> inter_arrival_; |
| 114 Random random_; |
118 }; | 115 }; |
119 | 116 |
120 TEST_F(OveruseDetectorTest, GaussianRandom) { | 117 TEST_F(OveruseDetectorTest, GaussianRandom) { |
121 int buckets[100]; | 118 int buckets[100]; |
122 memset(buckets, 0, sizeof(buckets)); | 119 memset(buckets, 0, sizeof(buckets)); |
123 for (int i = 0; i < 100000; ++i) { | 120 for (int i = 0; i < 100000; ++i) { |
124 int index = GaussianRandom(49, 10); | 121 int index = random_.Gaussian(49, 10); |
125 if (index >= 0 && index < 100) | 122 if (index >= 0 && index < 100) |
126 buckets[index]++; | 123 buckets[index]++; |
127 } | 124 } |
128 for (int n = 0; n < 100; ++n) { | 125 for (int n = 0; n < 100; ++n) { |
129 printf("Bucket n:%d, %d\n", n, buckets[n]); | 126 printf("Bucket n:%d, %d\n", n, buckets[n]); |
130 } | 127 } |
131 } | 128 } |
132 | 129 |
133 TEST_F(OveruseDetectorTest, SimpleNonOveruse30fps) { | 130 TEST_F(OveruseDetectorTest, SimpleNonOveruse30fps) { |
134 size_t packet_size = 1200; | 131 size_t packet_size = 1200; |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
185 int packets_per_frame = 6; | 182 int packets_per_frame = 6; |
186 int frame_duration_ms = 33; | 183 int frame_duration_ms = 33; |
187 int drift_per_frame_ms = 1; | 184 int drift_per_frame_ms = 1; |
188 int sigma_ms = 0; // No variance. | 185 int sigma_ms = 0; // No variance. |
189 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 186 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
190 frame_duration_ms, sigma_ms); | 187 frame_duration_ms, sigma_ms); |
191 | 188 |
192 EXPECT_EQ(0, unique_overuse); | 189 EXPECT_EQ(0, unique_overuse); |
193 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 190 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
194 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 191 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
195 EXPECT_EQ(6, frames_until_overuse); | 192 EXPECT_EQ(11, frames_until_overuse); |
196 } | 193 } |
197 | 194 |
198 TEST_F(OveruseDetectorTest, SimpleOveruse100kbit10fps) { | 195 TEST_F(OveruseDetectorTest, SimpleOveruse100kbit10fps) { |
199 size_t packet_size = 1200; | 196 size_t packet_size = 1200; |
200 int packets_per_frame = 1; | 197 int packets_per_frame = 1; |
201 int frame_duration_ms = 100; | 198 int frame_duration_ms = 100; |
202 int drift_per_frame_ms = 1; | 199 int drift_per_frame_ms = 1; |
203 int sigma_ms = 0; // No variance. | 200 int sigma_ms = 0; // No variance. |
204 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 201 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
205 frame_duration_ms, sigma_ms); | 202 frame_duration_ms, sigma_ms); |
206 | 203 |
207 EXPECT_EQ(0, unique_overuse); | 204 EXPECT_EQ(0, unique_overuse); |
208 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 205 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
209 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 206 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
210 EXPECT_EQ(4, frames_until_overuse); | 207 EXPECT_EQ(11, frames_until_overuse); |
211 } | 208 } |
212 | 209 |
213 TEST_F(OveruseDetectorTest, DISABLED_OveruseWithHighVariance100Kbit10fps) { | 210 TEST_F(OveruseDetectorTest, DISABLED_OveruseWithHighVariance100Kbit10fps) { |
214 uint32_t frame_duration_ms = 100; | 211 uint32_t frame_duration_ms = 100; |
215 uint32_t drift_per_frame_ms = 10; | 212 uint32_t drift_per_frame_ms = 10; |
216 uint32_t rtp_timestamp = frame_duration_ms * 90; | 213 uint32_t rtp_timestamp = frame_duration_ms * 90; |
217 size_t packet_size = 1200; | 214 size_t packet_size = 1200; |
218 int offset = 10; | 215 int offset = 10; |
219 | 216 |
220 // Run 1000 samples to reach steady state. | 217 // Run 1000 samples to reach steady state. |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
292 if (i % 2) { | 289 if (i % 2) { |
293 offset = rand() % 2; | 290 offset = rand() % 2; |
294 now_ms_ += frame_duration_ms - offset; | 291 now_ms_ += frame_duration_ms - offset; |
295 } else { | 292 } else { |
296 now_ms_ += frame_duration_ms + offset; | 293 now_ms_ += frame_duration_ms + offset; |
297 } | 294 } |
298 EXPECT_EQ(kBwNormal, overuse_detector_->State()); | 295 EXPECT_EQ(kBwNormal, overuse_detector_->State()); |
299 } | 296 } |
300 // Simulate a higher send pace, that is too high. | 297 // Simulate a higher send pace, that is too high. |
301 // Total build up of 30 ms. | 298 // Total build up of 30 ms. |
302 for (int j = 0; j < 5; ++j) { | 299 for (int j = 0; j < 4; ++j) { |
303 UpdateDetector(rtp_timestamp, now_ms_, packet_size); | 300 UpdateDetector(rtp_timestamp, now_ms_, packet_size); |
304 UpdateDetector(rtp_timestamp, now_ms_, packet_size); | 301 UpdateDetector(rtp_timestamp, now_ms_, packet_size); |
305 UpdateDetector(rtp_timestamp, now_ms_, packet_size); | 302 UpdateDetector(rtp_timestamp, now_ms_, packet_size); |
306 UpdateDetector(rtp_timestamp, now_ms_, packet_size); | 303 UpdateDetector(rtp_timestamp, now_ms_, packet_size); |
307 UpdateDetector(rtp_timestamp, now_ms_, packet_size); | 304 UpdateDetector(rtp_timestamp, now_ms_, packet_size); |
308 UpdateDetector(rtp_timestamp, now_ms_, packet_size); | 305 UpdateDetector(rtp_timestamp, now_ms_, packet_size); |
309 now_ms_ += frame_duration_ms + drift_per_frame_ms * 6; | 306 now_ms_ += frame_duration_ms + drift_per_frame_ms * 6; |
310 rtp_timestamp += frame_duration_ms * 90; | 307 rtp_timestamp += frame_duration_ms * 90; |
311 EXPECT_EQ(kBwNormal, overuse_detector_->State()); | 308 EXPECT_EQ(kBwNormal, overuse_detector_->State()); |
312 } | 309 } |
313 UpdateDetector(rtp_timestamp, now_ms_, packet_size); | 310 UpdateDetector(rtp_timestamp, now_ms_, packet_size); |
314 EXPECT_EQ(kBwOverusing, overuse_detector_->State()); | 311 EXPECT_EQ(kBwOverusing, overuse_detector_->State()); |
315 } | 312 } |
316 | 313 |
317 TEST_F(OveruseDetectorTest, | 314 TEST_F(OveruseDetectorTest, |
318 DISABLED_ON_ANDROID(LowGaussianVariance30Kbit3fps)) { | 315 DISABLED_ON_ANDROID(LowGaussianVariance30Kbit3fps)) { |
319 size_t packet_size = 1200; | 316 size_t packet_size = 1200; |
320 int packets_per_frame = 1; | 317 int packets_per_frame = 1; |
321 int frame_duration_ms = 333; | 318 int frame_duration_ms = 333; |
322 int drift_per_frame_ms = 1; | 319 int drift_per_frame_ms = 1; |
323 int sigma_ms = 3; | 320 int sigma_ms = 3; |
324 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 321 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
325 frame_duration_ms, sigma_ms); | 322 frame_duration_ms, sigma_ms); |
326 EXPECT_EQ(0, unique_overuse); | 323 EXPECT_EQ(0, unique_overuse); |
327 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 324 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
328 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 325 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
329 EXPECT_NEAR(29, frames_until_overuse, 5); | 326 EXPECT_EQ(36, frames_until_overuse); |
330 } | 327 } |
331 | 328 |
332 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift30Kbit3fps) { | 329 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift30Kbit3fps) { |
333 size_t packet_size = 1200; | 330 size_t packet_size = 1200; |
334 int packets_per_frame = 1; | 331 int packets_per_frame = 1; |
335 int frame_duration_ms = 333; | 332 int frame_duration_ms = 333; |
336 int drift_per_frame_ms = 100; | 333 int drift_per_frame_ms = 100; |
337 int sigma_ms = 3; | 334 int sigma_ms = 3; |
338 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 335 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
339 frame_duration_ms, sigma_ms); | 336 frame_duration_ms, sigma_ms); |
340 EXPECT_EQ(0, unique_overuse); | 337 EXPECT_EQ(0, unique_overuse); |
341 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 338 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
342 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 339 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
343 EXPECT_NEAR(4, frames_until_overuse, 1); | 340 EXPECT_EQ(4, frames_until_overuse); |
344 } | 341 } |
345 | 342 |
346 TEST_F(OveruseDetectorTest, HighGaussianVariance30Kbit3fps) { | 343 TEST_F(OveruseDetectorTest, HighGaussianVariance30Kbit3fps) { |
347 size_t packet_size = 1200; | 344 size_t packet_size = 1200; |
348 int packets_per_frame = 1; | 345 int packets_per_frame = 1; |
349 int frame_duration_ms = 333; | 346 int frame_duration_ms = 333; |
350 int drift_per_frame_ms = 1; | 347 int drift_per_frame_ms = 1; |
351 int sigma_ms = 10; | 348 int sigma_ms = 10; |
352 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 349 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
353 frame_duration_ms, sigma_ms); | 350 frame_duration_ms, sigma_ms); |
354 EXPECT_EQ(0, unique_overuse); | 351 EXPECT_EQ(0, unique_overuse); |
355 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 352 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
356 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 353 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
357 EXPECT_NEAR(79, frames_until_overuse, 30); | 354 EXPECT_EQ(119, frames_until_overuse); |
358 } | 355 } |
359 | 356 |
360 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift30Kbit3fps) { | 357 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift30Kbit3fps) { |
361 size_t packet_size = 1200; | 358 size_t packet_size = 1200; |
362 int packets_per_frame = 1; | 359 int packets_per_frame = 1; |
363 int frame_duration_ms = 333; | 360 int frame_duration_ms = 333; |
364 int drift_per_frame_ms = 100; | 361 int drift_per_frame_ms = 100; |
365 int sigma_ms = 10; | 362 int sigma_ms = 10; |
366 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 363 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
367 frame_duration_ms, sigma_ms); | 364 frame_duration_ms, sigma_ms); |
368 EXPECT_EQ(0, unique_overuse); | 365 EXPECT_EQ(0, unique_overuse); |
369 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 366 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
370 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 367 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
371 EXPECT_NEAR(4, frames_until_overuse, 1); | 368 EXPECT_EQ(5, frames_until_overuse); |
372 } | 369 } |
373 | 370 |
374 TEST_F(OveruseDetectorTest, | 371 TEST_F(OveruseDetectorTest, |
375 DISABLED_ON_ANDROID(LowGaussianVariance100Kbit5fps)) { | 372 DISABLED_ON_ANDROID(LowGaussianVariance100Kbit5fps)) { |
376 size_t packet_size = 1200; | 373 size_t packet_size = 1200; |
377 int packets_per_frame = 2; | 374 int packets_per_frame = 2; |
378 int frame_duration_ms = 200; | 375 int frame_duration_ms = 200; |
379 int drift_per_frame_ms = 1; | 376 int drift_per_frame_ms = 1; |
380 int sigma_ms = 3; | 377 int sigma_ms = 3; |
381 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 378 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
382 frame_duration_ms, sigma_ms); | 379 frame_duration_ms, sigma_ms); |
383 EXPECT_EQ(0, unique_overuse); | 380 EXPECT_EQ(0, unique_overuse); |
384 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 381 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
385 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 382 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
386 EXPECT_NEAR(29, frames_until_overuse, 5); | 383 EXPECT_EQ(35, frames_until_overuse); |
387 } | 384 } |
388 | 385 |
389 TEST_F(OveruseDetectorTest, | 386 TEST_F(OveruseDetectorTest, |
390 DISABLED_ON_ANDROID(HighGaussianVariance100Kbit5fps)) { | 387 DISABLED_ON_ANDROID(HighGaussianVariance100Kbit5fps)) { |
391 size_t packet_size = 1200; | 388 size_t packet_size = 1200; |
392 int packets_per_frame = 2; | 389 int packets_per_frame = 2; |
393 int frame_duration_ms = 200; | 390 int frame_duration_ms = 200; |
394 int drift_per_frame_ms = 1; | 391 int drift_per_frame_ms = 1; |
395 int sigma_ms = 10; | 392 int sigma_ms = 10; |
396 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 393 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
397 frame_duration_ms, sigma_ms); | 394 frame_duration_ms, sigma_ms); |
398 EXPECT_EQ(0, unique_overuse); | 395 EXPECT_EQ(0, unique_overuse); |
399 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 396 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
400 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 397 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
401 EXPECT_NEAR(79, frames_until_overuse, 15); | 398 EXPECT_EQ(115, frames_until_overuse); |
402 } | 399 } |
403 | 400 |
404 TEST_F(OveruseDetectorTest, | 401 TEST_F(OveruseDetectorTest, |
405 DISABLED_ON_ANDROID(LowGaussianVariance100Kbit10fps)) { | 402 DISABLED_ON_ANDROID(LowGaussianVariance100Kbit10fps)) { |
406 size_t packet_size = 1200; | 403 size_t packet_size = 1200; |
407 int packets_per_frame = 1; | 404 int packets_per_frame = 1; |
408 int frame_duration_ms = 100; | 405 int frame_duration_ms = 100; |
409 int drift_per_frame_ms = 1; | 406 int drift_per_frame_ms = 1; |
410 int sigma_ms = 3; | 407 int sigma_ms = 3; |
411 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 408 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
412 frame_duration_ms, sigma_ms); | 409 frame_duration_ms, sigma_ms); |
413 EXPECT_EQ(0, unique_overuse); | 410 EXPECT_EQ(0, unique_overuse); |
414 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 411 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
415 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 412 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
416 EXPECT_NEAR(29, frames_until_overuse, 5); | 413 EXPECT_EQ(30, frames_until_overuse); |
417 } | 414 } |
418 | 415 |
419 TEST_F(OveruseDetectorTest, | 416 TEST_F(OveruseDetectorTest, |
420 DISABLED_ON_ANDROID(HighGaussianVariance100Kbit10fps)) { | 417 DISABLED_ON_ANDROID(HighGaussianVariance100Kbit10fps)) { |
421 size_t packet_size = 1200; | 418 size_t packet_size = 1200; |
422 int packets_per_frame = 1; | 419 int packets_per_frame = 1; |
423 int frame_duration_ms = 100; | 420 int frame_duration_ms = 100; |
424 int drift_per_frame_ms = 1; | 421 int drift_per_frame_ms = 1; |
425 int sigma_ms = 10; | 422 int sigma_ms = 10; |
426 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 423 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
427 frame_duration_ms, sigma_ms); | 424 frame_duration_ms, sigma_ms); |
428 EXPECT_EQ(0, unique_overuse); | 425 EXPECT_EQ(0, unique_overuse); |
429 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 426 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
430 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 427 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
431 EXPECT_NEAR(79, frames_until_overuse, 15); | 428 EXPECT_EQ(98, frames_until_overuse); |
432 } | 429 } |
433 | 430 |
434 TEST_F(OveruseDetectorTest, | 431 TEST_F(OveruseDetectorTest, |
435 DISABLED_ON_ANDROID(LowGaussianVariance300Kbit30fps)) { | 432 DISABLED_ON_ANDROID(LowGaussianVariance300Kbit30fps)) { |
436 size_t packet_size = 1200; | 433 size_t packet_size = 1200; |
437 int packets_per_frame = 1; | 434 int packets_per_frame = 1; |
438 int frame_duration_ms = 33; | 435 int frame_duration_ms = 33; |
439 int drift_per_frame_ms = 1; | 436 int drift_per_frame_ms = 1; |
440 int sigma_ms = 3; | 437 int sigma_ms = 3; |
441 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 438 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
442 frame_duration_ms, sigma_ms); | 439 frame_duration_ms, sigma_ms); |
443 EXPECT_EQ(0, unique_overuse); | 440 EXPECT_EQ(0, unique_overuse); |
444 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 441 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
445 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 442 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
446 EXPECT_NEAR(30, frames_until_overuse, 5); | 443 EXPECT_EQ(30, frames_until_overuse); |
447 } | 444 } |
448 | 445 |
449 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift300Kbit30fps) { | 446 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift300Kbit30fps) { |
450 size_t packet_size = 1200; | 447 size_t packet_size = 1200; |
451 int packets_per_frame = 1; | 448 int packets_per_frame = 1; |
452 int frame_duration_ms = 33; | 449 int frame_duration_ms = 33; |
453 int drift_per_frame_ms = 10; | 450 int drift_per_frame_ms = 10; |
454 int sigma_ms = 3; | 451 int sigma_ms = 3; |
455 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 452 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
456 frame_duration_ms, sigma_ms); | 453 frame_duration_ms, sigma_ms); |
457 EXPECT_EQ(0, unique_overuse); | 454 EXPECT_EQ(0, unique_overuse); |
458 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 455 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
459 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 456 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
460 EXPECT_NEAR(7, frames_until_overuse, 1); | 457 EXPECT_EQ(6, frames_until_overuse); |
461 } | 458 } |
462 | 459 |
463 TEST_F(OveruseDetectorTest, HighGaussianVariance300Kbit30fps) { | 460 TEST_F(OveruseDetectorTest, HighGaussianVariance300Kbit30fps) { |
464 size_t packet_size = 1200; | 461 size_t packet_size = 1200; |
465 int packets_per_frame = 1; | 462 int packets_per_frame = 1; |
466 int frame_duration_ms = 33; | 463 int frame_duration_ms = 33; |
467 int drift_per_frame_ms = 1; | 464 int drift_per_frame_ms = 1; |
468 int sigma_ms = 10; | 465 int sigma_ms = 10; |
469 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 466 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
470 frame_duration_ms, sigma_ms); | 467 frame_duration_ms, sigma_ms); |
471 EXPECT_EQ(0, unique_overuse); | 468 EXPECT_EQ(0, unique_overuse); |
472 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 469 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
473 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 470 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
474 EXPECT_NEAR(98, frames_until_overuse, 22); | 471 EXPECT_EQ(98, frames_until_overuse); |
475 } | 472 } |
476 | 473 |
477 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift300Kbit30fps) { | 474 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift300Kbit30fps) { |
478 size_t packet_size = 1200; | 475 size_t packet_size = 1200; |
479 int packets_per_frame = 1; | 476 int packets_per_frame = 1; |
480 int frame_duration_ms = 33; | 477 int frame_duration_ms = 33; |
481 int drift_per_frame_ms = 10; | 478 int drift_per_frame_ms = 10; |
482 int sigma_ms = 10; | 479 int sigma_ms = 10; |
483 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 480 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
484 frame_duration_ms, sigma_ms); | 481 frame_duration_ms, sigma_ms); |
485 EXPECT_EQ(0, unique_overuse); | 482 EXPECT_EQ(0, unique_overuse); |
486 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 483 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
487 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 484 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
488 EXPECT_NEAR(12, frames_until_overuse, 2); | 485 EXPECT_EQ(12, frames_until_overuse); |
489 } | 486 } |
490 | 487 |
491 TEST_F(OveruseDetectorTest, | 488 TEST_F(OveruseDetectorTest, |
492 DISABLED_ON_ANDROID(LowGaussianVariance1000Kbit30fps)) { | 489 DISABLED_ON_ANDROID(LowGaussianVariance1000Kbit30fps)) { |
493 size_t packet_size = 1200; | 490 size_t packet_size = 1200; |
494 int packets_per_frame = 3; | 491 int packets_per_frame = 3; |
495 int frame_duration_ms = 33; | 492 int frame_duration_ms = 33; |
496 int drift_per_frame_ms = 1; | 493 int drift_per_frame_ms = 1; |
497 int sigma_ms = 3; | 494 int sigma_ms = 3; |
498 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 495 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
499 frame_duration_ms, sigma_ms); | 496 frame_duration_ms, sigma_ms); |
500 EXPECT_EQ(0, unique_overuse); | 497 EXPECT_EQ(0, unique_overuse); |
501 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 498 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
502 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 499 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
503 EXPECT_NEAR(30, frames_until_overuse, 5); | 500 EXPECT_EQ(30, frames_until_overuse); |
504 } | 501 } |
505 | 502 |
506 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift1000Kbit30fps) { | 503 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift1000Kbit30fps) { |
507 size_t packet_size = 1200; | 504 size_t packet_size = 1200; |
508 int packets_per_frame = 3; | 505 int packets_per_frame = 3; |
509 int frame_duration_ms = 33; | 506 int frame_duration_ms = 33; |
510 int drift_per_frame_ms = 10; | 507 int drift_per_frame_ms = 10; |
511 int sigma_ms = 3; | 508 int sigma_ms = 3; |
512 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 509 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
513 frame_duration_ms, sigma_ms); | 510 frame_duration_ms, sigma_ms); |
514 EXPECT_EQ(0, unique_overuse); | 511 EXPECT_EQ(0, unique_overuse); |
515 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 512 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
516 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 513 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
517 EXPECT_NEAR(7, frames_until_overuse, 1); | 514 EXPECT_EQ(6, frames_until_overuse); |
518 } | 515 } |
519 | 516 |
520 TEST_F(OveruseDetectorTest, HighGaussianVariance1000Kbit30fps) { | 517 TEST_F(OveruseDetectorTest, HighGaussianVariance1000Kbit30fps) { |
521 size_t packet_size = 1200; | 518 size_t packet_size = 1200; |
522 int packets_per_frame = 3; | 519 int packets_per_frame = 3; |
523 int frame_duration_ms = 33; | 520 int frame_duration_ms = 33; |
524 int drift_per_frame_ms = 1; | 521 int drift_per_frame_ms = 1; |
525 int sigma_ms = 10; | 522 int sigma_ms = 10; |
526 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 523 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
527 frame_duration_ms, sigma_ms); | 524 frame_duration_ms, sigma_ms); |
528 EXPECT_EQ(0, unique_overuse); | 525 EXPECT_EQ(0, unique_overuse); |
529 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 526 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
530 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 527 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
531 EXPECT_NEAR(98, frames_until_overuse, 22); | 528 EXPECT_EQ(98, frames_until_overuse); |
532 } | 529 } |
533 | 530 |
534 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift1000Kbit30fps) { | 531 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift1000Kbit30fps) { |
535 size_t packet_size = 1200; | 532 size_t packet_size = 1200; |
536 int packets_per_frame = 3; | 533 int packets_per_frame = 3; |
537 int frame_duration_ms = 33; | 534 int frame_duration_ms = 33; |
538 int drift_per_frame_ms = 10; | 535 int drift_per_frame_ms = 10; |
539 int sigma_ms = 10; | 536 int sigma_ms = 10; |
540 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 537 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
541 frame_duration_ms, sigma_ms); | 538 frame_duration_ms, sigma_ms); |
542 EXPECT_EQ(0, unique_overuse); | 539 EXPECT_EQ(0, unique_overuse); |
543 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 540 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
544 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 541 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
545 EXPECT_NEAR(12, frames_until_overuse, 2); | 542 EXPECT_EQ(12, frames_until_overuse); |
546 } | 543 } |
547 | 544 |
548 TEST_F(OveruseDetectorTest, | 545 TEST_F(OveruseDetectorTest, |
549 DISABLED_ON_ANDROID(LowGaussianVariance2000Kbit30fps)) { | 546 DISABLED_ON_ANDROID(LowGaussianVariance2000Kbit30fps)) { |
550 size_t packet_size = 1200; | 547 size_t packet_size = 1200; |
551 int packets_per_frame = 6; | 548 int packets_per_frame = 6; |
552 int frame_duration_ms = 33; | 549 int frame_duration_ms = 33; |
553 int drift_per_frame_ms = 1; | 550 int drift_per_frame_ms = 1; |
554 int sigma_ms = 3; | 551 int sigma_ms = 3; |
555 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 552 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
556 frame_duration_ms, sigma_ms); | 553 frame_duration_ms, sigma_ms); |
557 EXPECT_EQ(0, unique_overuse); | 554 EXPECT_EQ(0, unique_overuse); |
558 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 555 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
559 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 556 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
560 EXPECT_NEAR(30, frames_until_overuse, 5); | 557 EXPECT_EQ(30, frames_until_overuse); |
561 } | 558 } |
562 | 559 |
563 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift2000Kbit30fps) { | 560 TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift2000Kbit30fps) { |
564 size_t packet_size = 1200; | 561 size_t packet_size = 1200; |
565 int packets_per_frame = 6; | 562 int packets_per_frame = 6; |
566 int frame_duration_ms = 33; | 563 int frame_duration_ms = 33; |
567 int drift_per_frame_ms = 10; | 564 int drift_per_frame_ms = 10; |
568 int sigma_ms = 3; | 565 int sigma_ms = 3; |
569 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 566 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
570 frame_duration_ms, sigma_ms); | 567 frame_duration_ms, sigma_ms); |
571 EXPECT_EQ(0, unique_overuse); | 568 EXPECT_EQ(0, unique_overuse); |
572 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 569 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
573 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 570 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
574 EXPECT_NEAR(7, frames_until_overuse, 1); | 571 EXPECT_EQ(6, frames_until_overuse); |
575 } | 572 } |
576 | 573 |
577 TEST_F(OveruseDetectorTest, HighGaussianVariance2000Kbit30fps) { | 574 TEST_F(OveruseDetectorTest, HighGaussianVariance2000Kbit30fps) { |
578 size_t packet_size = 1200; | 575 size_t packet_size = 1200; |
579 int packets_per_frame = 6; | 576 int packets_per_frame = 6; |
580 int frame_duration_ms = 33; | 577 int frame_duration_ms = 33; |
581 int drift_per_frame_ms = 1; | 578 int drift_per_frame_ms = 1; |
582 int sigma_ms = 10; | 579 int sigma_ms = 10; |
583 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 580 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
584 frame_duration_ms, sigma_ms); | 581 frame_duration_ms, sigma_ms); |
585 EXPECT_EQ(0, unique_overuse); | 582 EXPECT_EQ(0, unique_overuse); |
586 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 583 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
587 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 584 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
588 EXPECT_NEAR(98, frames_until_overuse, 22); | 585 EXPECT_EQ(98, frames_until_overuse); |
589 } | 586 } |
590 | 587 |
591 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift2000Kbit30fps) { | 588 TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift2000Kbit30fps) { |
592 size_t packet_size = 1200; | 589 size_t packet_size = 1200; |
593 int packets_per_frame = 6; | 590 int packets_per_frame = 6; |
594 int frame_duration_ms = 33; | 591 int frame_duration_ms = 33; |
595 int drift_per_frame_ms = 10; | 592 int drift_per_frame_ms = 10; |
596 int sigma_ms = 10; | 593 int sigma_ms = 10; |
597 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | 594 int unique_overuse = Run100000Samples(packets_per_frame, packet_size, |
598 frame_duration_ms, sigma_ms); | 595 frame_duration_ms, sigma_ms); |
599 EXPECT_EQ(0, unique_overuse); | 596 EXPECT_EQ(0, unique_overuse); |
600 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, | 597 int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, |
601 frame_duration_ms, sigma_ms, drift_per_frame_ms); | 598 frame_duration_ms, sigma_ms, drift_per_frame_ms); |
602 EXPECT_NEAR(12, frames_until_overuse, 2); | 599 EXPECT_EQ(12, frames_until_overuse); |
| 600 } |
| 601 |
| 602 class AdaptiveThresholdDetector : public OveruseDetector { |
| 603 public: |
| 604 explicit AdaptiveThresholdDetector(const OverUseDetectorOptions& options) |
| 605 : OveruseDetector(options) {} |
| 606 |
| 607 virtual ~AdaptiveThresholdDetector() {} |
| 608 |
| 609 bool AdaptiveThresholdExperimentIsEnabled() const override { return true; } |
| 610 }; |
| 611 |
| 612 TEST_F(OveruseDetectorTest, ThresholdAdapts) { |
| 613 overuse_detector_.reset(new AdaptiveThresholdDetector(options_)); |
| 614 const double kOffset = 0.21; |
| 615 double kTsDelta = 3000.0; |
| 616 int64_t now_ms = 0; |
| 617 int num_deltas = 60; |
| 618 const int kBatchLength = 10; |
| 619 |
| 620 // Pass in a positive offset and verify it triggers overuse. |
| 621 bool overuse_detected = false; |
| 622 for (int i = 0; i < kBatchLength; ++i) { |
| 623 BandwidthUsage overuse_state = |
| 624 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms); |
| 625 if (overuse_state == kBwOverusing) { |
| 626 overuse_detected = true; |
| 627 } |
| 628 ++num_deltas; |
| 629 now_ms += 5; |
| 630 } |
| 631 EXPECT_TRUE(overuse_detected); |
| 632 |
| 633 // Force the threshold to increase by passing in a higher offset. |
| 634 overuse_detected = false; |
| 635 for (int i = 0; i < kBatchLength; ++i) { |
| 636 BandwidthUsage overuse_state = |
| 637 overuse_detector_->Detect(1.1 * kOffset, kTsDelta, num_deltas, now_ms); |
| 638 if (overuse_state == kBwOverusing) { |
| 639 overuse_detected = true; |
| 640 } |
| 641 ++num_deltas; |
| 642 now_ms += 5; |
| 643 } |
| 644 EXPECT_TRUE(overuse_detected); |
| 645 |
| 646 // Verify that the same offset as before no longer triggers overuse. |
| 647 overuse_detected = false; |
| 648 for (int i = 0; i < kBatchLength; ++i) { |
| 649 BandwidthUsage overuse_state = |
| 650 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms); |
| 651 if (overuse_state == kBwOverusing) { |
| 652 overuse_detected = true; |
| 653 } |
| 654 ++num_deltas; |
| 655 now_ms += 5; |
| 656 } |
| 657 EXPECT_FALSE(overuse_detected); |
| 658 |
| 659 // Pass in a low offset to make the threshold adapt down. |
| 660 for (int i = 0; i < 15 * kBatchLength; ++i) { |
| 661 BandwidthUsage overuse_state = |
| 662 overuse_detector_->Detect(0.7 * kOffset, kTsDelta, num_deltas, now_ms); |
| 663 if (overuse_state == kBwOverusing) { |
| 664 overuse_detected = true; |
| 665 } |
| 666 ++num_deltas; |
| 667 now_ms += 5; |
| 668 } |
| 669 EXPECT_FALSE(overuse_detected); |
| 670 |
| 671 // Make sure the original offset now again triggers overuse. |
| 672 for (int i = 0; i < kBatchLength; ++i) { |
| 673 BandwidthUsage overuse_state = |
| 674 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms); |
| 675 if (overuse_state == kBwOverusing) { |
| 676 overuse_detected = true; |
| 677 } |
| 678 ++num_deltas; |
| 679 now_ms += 5; |
| 680 } |
| 681 EXPECT_TRUE(overuse_detected); |
| 682 } |
| 683 |
| 684 TEST_F(OveruseDetectorTest, DoesntAdaptToSpikes) { |
| 685 overuse_detector_.reset(new AdaptiveThresholdDetector(options_)); |
| 686 const double kOffset = 1.0; |
| 687 const double kLargeOffset = 20.0; |
| 688 double kTsDelta = 3000.0; |
| 689 int64_t now_ms = 0; |
| 690 int num_deltas = 60; |
| 691 const int kBatchLength = 10; |
| 692 const int kShortBatchLength = 3; |
| 693 |
| 694 // Pass in a positive offset and verify it triggers overuse. |
| 695 bool overuse_detected = false; |
| 696 for (int i = 0; i < kBatchLength; ++i) { |
| 697 BandwidthUsage overuse_state = |
| 698 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms); |
| 699 if (overuse_state == kBwOverusing) { |
| 700 overuse_detected = true; |
| 701 } |
| 702 ++num_deltas; |
| 703 now_ms += 5; |
| 704 } |
| 705 |
| 706 // Pass in a large offset. This shouldn't have a too big impact on the |
| 707 // threshold, but still trigger an overuse. |
| 708 now_ms += 100; |
| 709 overuse_detected = false; |
| 710 for (int i = 0; i < kShortBatchLength; ++i) { |
| 711 BandwidthUsage overuse_state = |
| 712 overuse_detector_->Detect(kLargeOffset, kTsDelta, num_deltas, now_ms); |
| 713 if (overuse_state == kBwOverusing) { |
| 714 overuse_detected = true; |
| 715 } |
| 716 ++num_deltas; |
| 717 now_ms += 5; |
| 718 } |
| 719 EXPECT_TRUE(overuse_detected); |
| 720 |
| 721 // Pass in a positive normal offset and verify it still triggers. |
| 722 overuse_detected = false; |
| 723 for (int i = 0; i < kBatchLength; ++i) { |
| 724 BandwidthUsage overuse_state = |
| 725 overuse_detector_->Detect(kOffset, kTsDelta, num_deltas, now_ms); |
| 726 if (overuse_state == kBwOverusing) { |
| 727 overuse_detected = true; |
| 728 } |
| 729 ++num_deltas; |
| 730 now_ms += 5; |
| 731 } |
| 732 EXPECT_TRUE(overuse_detected); |
603 } | 733 } |
604 } // namespace testing | 734 } // namespace testing |
605 } // namespace webrtc | 735 } // namespace webrtc |
OLD | NEW |