| /* | |
| * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | |
| * | |
| * Use of this source code is governed by a BSD-style license | |
| * that can be found in the LICENSE file in the root of the source | |
| * tree. An additional intellectual property rights grant can be found | |
| * in the file PATENTS. All contributing project authors may | |
| * be found in the AUTHORS file in the root of the source tree. | |
| */ | |
| #include "modules/remote_bitrate_estimator/overuse_detector.h" | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <algorithm> | |
| #include <cstdlib> | |
| #include <memory> | |
| #include "modules/remote_bitrate_estimator/inter_arrival.h" | |
| #include "modules/remote_bitrate_estimator/overuse_estimator.h" | |
| #include "rtc_base/random.h" | |
| #include "test/gtest.h" | |
| namespace webrtc { | |
| namespace testing { | |
| const double kRtpTimestampToMs = 1.0 / 90.0; | |
| class OveruseDetectorTest : public ::testing::Test { | |
| public: | |
| OveruseDetectorTest() | |
| : now_ms_(0), | |
| receive_time_ms_(0), | |
| rtp_timestamp_(10 * 90), | |
| inter_arrival_(5 * 90, kRtpTimestampToMs), | |
| random_(123456789) {} | |
| protected: | |
| int Run100000Samples(int packets_per_frame, | |
| size_t packet_size, | |
| int mean_ms, | |
| int standard_deviation_ms) { | |
| int unique_overuse = 0; | |
| int last_overuse = -1; | |
| for (int i = 0; i < 100000; ++i) { | |
| for (int j = 0; j < packets_per_frame; ++j) { | |
| UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size); | |
| } | |
| rtp_timestamp_ += mean_ms * 90; | |
| now_ms_ += mean_ms; | |
| receive_time_ms_ = std::max<int64_t>( | |
| receive_time_ms_, | |
| now_ms_ + static_cast<int64_t>( | |
| random_.Gaussian(0, standard_deviation_ms) + 0.5)); | |
| if (BandwidthUsage::kBwOverusing == overuse_detector_.State()) { | |
| if (last_overuse + 1 != i) { | |
| unique_overuse++; | |
| } | |
| last_overuse = i; | |
| } | |
| } | |
| return unique_overuse; | |
| } | |
| int RunUntilOveruse(int packets_per_frame, | |
| size_t packet_size, | |
| int mean_ms, | |
| int standard_deviation_ms, | |
| int drift_per_frame_ms) { | |
| // Simulate a higher send pace, that is too high. | |
| for (int i = 0; i < 1000; ++i) { | |
| for (int j = 0; j < packets_per_frame; ++j) { | |
| UpdateDetector(rtp_timestamp_, receive_time_ms_, packet_size); | |
| } | |
| rtp_timestamp_ += mean_ms * 90; | |
| now_ms_ += mean_ms + drift_per_frame_ms; | |
| receive_time_ms_ = std::max<int64_t>( | |
| receive_time_ms_, | |
| now_ms_ + static_cast<int64_t>( | |
| random_.Gaussian(0, standard_deviation_ms) + 0.5)); | |
| if (BandwidthUsage::kBwOverusing == overuse_detector_.State()) { | |
| return i + 1; | |
| } | |
| } | |
| return -1; | |
| } | |
| void UpdateDetector(uint32_t rtp_timestamp, | |
| int64_t receive_time_ms, | |
| size_t packet_size) { | |
| uint32_t timestamp_delta; | |
| int64_t time_delta; | |
| int size_delta; | |
| if (inter_arrival_.ComputeDeltas( | |
| rtp_timestamp, receive_time_ms, receive_time_ms, packet_size, | |
| ×tamp_delta, &time_delta, &size_delta)) { | |
| double timestamp_delta_ms = timestamp_delta / 90.0; | |
| overuse_estimator_.Update(time_delta, timestamp_delta_ms, size_delta, | |
| overuse_detector_.State(), receive_time_ms); | |
| overuse_detector_.Detect(overuse_estimator_.offset(), timestamp_delta_ms, | |
| overuse_estimator_.num_of_deltas(), | |
| receive_time_ms); | |
| } | |
| } | |
| int64_t now_ms_; | |
| int64_t receive_time_ms_; | |
| uint32_t rtp_timestamp_; | |
| OveruseDetector overuse_detector_; | |
| OveruseEstimator overuse_estimator_; | |
| InterArrival inter_arrival_; | |
| Random random_; | |
| }; | |
| TEST_F(OveruseDetectorTest, GaussianRandom) { | |
| int buckets[100]; | |
| memset(buckets, 0, sizeof(buckets)); | |
| for (int i = 0; i < 100000; ++i) { | |
| int index = random_.Gaussian(49, 10); | |
| if (index >= 0 && index < 100) | |
| buckets[index]++; | |
| } | |
| for (int n = 0; n < 100; ++n) { | |
| printf("Bucket n:%d, %d\n", n, buckets[n]); | |
| } | |
| } | |
| TEST_F(OveruseDetectorTest, SimpleNonOveruse30fps) { | |
| size_t packet_size = 1200; | |
| uint32_t frame_duration_ms = 33; | |
| uint32_t rtp_timestamp = 10 * 90; | |
| // No variance. | |
| for (int i = 0; i < 1000; ++i) { | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| now_ms_ += frame_duration_ms; | |
| rtp_timestamp += frame_duration_ms * 90; | |
| EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_.State()); | |
| } | |
| } | |
| // Roughly 1 Mbit/s | |
| TEST_F(OveruseDetectorTest, SimpleNonOveruseWithReceiveVariance) { | |
| uint32_t frame_duration_ms = 10; | |
| uint32_t rtp_timestamp = 10 * 90; | |
| size_t packet_size = 1200; | |
| for (int i = 0; i < 1000; ++i) { | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| rtp_timestamp += frame_duration_ms * 90; | |
| if (i % 2) { | |
| now_ms_ += frame_duration_ms - 5; | |
| } else { | |
| now_ms_ += frame_duration_ms + 5; | |
| } | |
| EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_.State()); | |
| } | |
| } | |
| TEST_F(OveruseDetectorTest, SimpleNonOveruseWithRtpTimestampVariance) { | |
| // Roughly 1 Mbit/s. | |
| uint32_t frame_duration_ms = 10; | |
| uint32_t rtp_timestamp = 10 * 90; | |
| size_t packet_size = 1200; | |
| for (int i = 0; i < 1000; ++i) { | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| now_ms_ += frame_duration_ms; | |
| if (i % 2) { | |
| rtp_timestamp += (frame_duration_ms - 5) * 90; | |
| } else { | |
| rtp_timestamp += (frame_duration_ms + 5) * 90; | |
| } | |
| EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_.State()); | |
| } | |
| } | |
| TEST_F(OveruseDetectorTest, SimpleOveruse2000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 6; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 0; // No variance. | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(7, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, SimpleOveruse100kbit10fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 100; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 0; // No variance. | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(7, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, OveruseWithLowVariance2000Kbit30fps) { | |
| uint32_t frame_duration_ms = 33; | |
| uint32_t drift_per_frame_ms = 1; | |
| uint32_t rtp_timestamp = frame_duration_ms * 90; | |
| size_t packet_size = 1200; | |
| int offset = 0; | |
| // Run 1000 samples to reach steady state. | |
| for (int i = 0; i < 1000; ++i) { | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| rtp_timestamp += frame_duration_ms * 90; | |
| if (i % 2) { | |
| offset = random_.Rand(0, 1); | |
| now_ms_ += frame_duration_ms - offset; | |
| } else { | |
| now_ms_ += frame_duration_ms + offset; | |
| } | |
| EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_.State()); | |
| } | |
| // Simulate a higher send pace, that is too high. | |
| // Total build up of 30 ms. | |
| for (int j = 0; j < 3; ++j) { | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| now_ms_ += frame_duration_ms + drift_per_frame_ms * 6; | |
| rtp_timestamp += frame_duration_ms * 90; | |
| EXPECT_EQ(BandwidthUsage::kBwNormal, overuse_detector_.State()); | |
| } | |
| UpdateDetector(rtp_timestamp, now_ms_, packet_size); | |
| EXPECT_EQ(BandwidthUsage::kBwOverusing, overuse_detector_.State()); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVariance30Kbit3fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 333; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(20, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift30Kbit3fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 333; | |
| int drift_per_frame_ms = 100; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(4, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVariance30Kbit3fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 333; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(44, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift30Kbit3fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 333; | |
| int drift_per_frame_ms = 100; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(4, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVariance100Kbit5fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 2; | |
| int frame_duration_ms = 200; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(20, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVariance100Kbit5fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 2; | |
| int frame_duration_ms = 200; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(44, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVariance100Kbit10fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 100; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(20, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVariance100Kbit10fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 100; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(44, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVariance300Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(19, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift300Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 10; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(5, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVariance300Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(44, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift300Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 1; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 10; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(10, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVariance1000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 3; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(19, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift1000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 3; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 10; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(5, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVariance1000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 3; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(44, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift1000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 3; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 10; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(10, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVariance2000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 6; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(19, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift2000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 6; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 10; | |
| int sigma_ms = 3; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(5, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVariance2000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 6; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 1; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(44, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, HighGaussianVarianceFastDrift2000Kbit30fps) { | |
| size_t packet_size = 1200; | |
| int packets_per_frame = 6; | |
| int frame_duration_ms = 33; | |
| int drift_per_frame_ms = 10; | |
| int sigma_ms = 10; | |
| int unique_overuse = Run100000Samples(packets_per_frame, packet_size, | |
| frame_duration_ms, sigma_ms); | |
| EXPECT_EQ(0, unique_overuse); | |
| int frames_until_overuse = | |
| RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, | |
| sigma_ms, drift_per_frame_ms); | |
| EXPECT_EQ(10, frames_until_overuse); | |
| } | |
| TEST_F(OveruseDetectorTest, ThresholdAdapts) { | |
| const double kOffset = 0.21; | |
| double kTsDelta = 3000.0; | |
| int64_t now_ms = 0; | |
| int num_deltas = 60; | |
| const int kBatchLength = 10; | |
| // Pass in a positive offset and verify it triggers overuse. | |
| bool overuse_detected = false; | |
| for (int i = 0; i < kBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(kOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| EXPECT_TRUE(overuse_detected); | |
| // Force the threshold to increase by passing in a higher offset. | |
| overuse_detected = false; | |
| for (int i = 0; i < kBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(1.1 * kOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| EXPECT_TRUE(overuse_detected); | |
| // Verify that the same offset as before no longer triggers overuse. | |
| overuse_detected = false; | |
| for (int i = 0; i < kBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(kOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| EXPECT_FALSE(overuse_detected); | |
| // Pass in a low offset to make the threshold adapt down. | |
| for (int i = 0; i < 15 * kBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(0.7 * kOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| EXPECT_FALSE(overuse_detected); | |
| // Make sure the original offset now again triggers overuse. | |
| for (int i = 0; i < kBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(kOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| EXPECT_TRUE(overuse_detected); | |
| } | |
| TEST_F(OveruseDetectorTest, DoesntAdaptToSpikes) { | |
| const double kOffset = 1.0; | |
| const double kLargeOffset = 20.0; | |
| double kTsDelta = 3000.0; | |
| int64_t now_ms = 0; | |
| int num_deltas = 60; | |
| const int kBatchLength = 10; | |
| const int kShortBatchLength = 3; | |
| // Pass in a positive offset and verify it triggers overuse. | |
| bool overuse_detected = false; | |
| for (int i = 0; i < kBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(kOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| // Pass in a large offset. This shouldn't have a too big impact on the | |
| // threshold, but still trigger an overuse. | |
| now_ms += 100; | |
| overuse_detected = false; | |
| for (int i = 0; i < kShortBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(kLargeOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| EXPECT_TRUE(overuse_detected); | |
| // Pass in a positive normal offset and verify it still triggers. | |
| overuse_detected = false; | |
| for (int i = 0; i < kBatchLength; ++i) { | |
| BandwidthUsage overuse_state = | |
| overuse_detector_.Detect(kOffset, kTsDelta, num_deltas, now_ms); | |
| if (overuse_state == BandwidthUsage::kBwOverusing) { | |
| overuse_detected = true; | |
| } | |
| ++num_deltas; | |
| now_ms += 5; | |
| } | |
| EXPECT_TRUE(overuse_detected); | |
| } | |
| } // namespace testing | |
| } // namespace webrtc |