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