admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ensure that loss based BWE can switch to kIncreasing state when it wants to increase.

Browse Source 
Increasing BWE by 1kbps should be safe/no-op in practice, and it ensures that padding in kIncreasing state will be triggered.

Bug: webrtc:12707
Change-Id: I82493d07a80abd60c93d9cff74baf0a55e77f2b7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/325286
Commit-Queue: Diep Bui <diepbp@webrtc.org>
Reviewed-by: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41046}
This commit is contained in:
Diep Bui 2023-10-31 09:55:36 +00:00 committed by WebRTC LUCI CQ
parent 51b93a5417
commit e920073a68
2 changed files with 58 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
modules/congestion_controller/goog_cc/loss_based_bwe_v2.cc
View File

@ -294,6 +294,15 @@ void LossBasedBweV2::UpdateBandwidthEstimate(
std::min(best_candidate.loss_limited_bandwidth,
config_->bandwidth_rampup_upper_bound_factor *
(*acknowledged_bitrate_)));
// Increase current estimate by at least 1kbps to make sure that the state
// will be switched to kIncreasing, thus padding is triggered.
if (loss_based_result_.state == LossBasedState::kDecreasing &&
best_candidate.loss_limited_bandwidth ==
current_best_estimate_.loss_limited_bandwidth) {
best_candidate.loss_limited_bandwidth =
current_best_estimate_.loss_limited_bandwidth +
DataRate::KilobitsPerSec(1);
}
}
}

50
modules/congestion_controller/goog_cc/loss_based_bwe_v2_test.cc
View File

@ -795,7 +795,7 @@ TEST_F(LossBasedBweV2Test,
// The estimate is capped by acked_bitrate * BwRampupUpperBoundFactor.
EXPECT_EQ(result.bandwidth_estimate, estimate_1 * 0.9 * 1.2);
// But if acked bitrate decrease, BWE does not decrease when there is no
// But if acked bitrate decreases, BWE does not decrease when there is no
// loss.
loss_based_bandwidth_estimator.SetAcknowledgedBitrate(estimate_1 * 0.9);
loss_based_bandwidth_estimator.UpdateBandwidthEstimate(
@ -809,6 +809,54 @@ TEST_F(LossBasedBweV2Test,
result.bandwidth_estimate);
}
// Ensure that the state can switch to kIncrease even when the bandwidth is
// bounded by acked bitrate.
TEST_F(LossBasedBweV2Test, EnsureIncreaseEvenIfAckedBitrateBound) {
ExplicitKeyValueConfig key_value_config(ShortObservationConfig(
"LossThresholdOfHighBandwidthPreference:0.99,"
"BwRampupUpperBoundFactor:1.2,"
// Set InstantUpperBoundBwBalance high to disable InstantUpperBound cap.
"InstantUpperBoundBwBalance:10000kbps,"));
std::vector<PacketResult> enough_feedback_1 =
CreatePacketResultsWith100pLossRate(
/*first_packet_timestamp=*/Timestamp::Zero());
LossBasedBweV2 loss_based_bandwidth_estimator(&key_value_config);
DataRate delay_based_estimate = DataRate::KilobitsPerSec(5000);
loss_based_bandwidth_estimator.SetBandwidthEstimate(
DataRate::KilobitsPerSec(600));
loss_based_bandwidth_estimator.SetAcknowledgedBitrate(
DataRate::KilobitsPerSec(300));
loss_based_bandwidth_estimator.UpdateBandwidthEstimate(enough_feedback_1,
delay_based_estimate,
/*in_alr=*/false);
ASSERT_EQ(loss_based_bandwidth_estimator.GetLossBasedResult().state,
LossBasedState::kDecreasing);
LossBasedBweV2::Result result =
loss_based_bandwidth_estimator.GetLossBasedResult();
DataRate estimate_1 = result.bandwidth_estimate;
ASSERT_LT(estimate_1.kbps(), 600);
// Set a low acked bitrate.
loss_based_bandwidth_estimator.SetAcknowledgedBitrate(estimate_1 / 2);
int feedback_count = 1;
while (feedback_count < 5 && result.state != LossBasedState::kIncreasing) {
loss_based_bandwidth_estimator.UpdateBandwidthEstimate(
CreatePacketResultsWithReceivedPackets(
/*first_packet_timestamp=*/Timestamp::Zero() +
feedback_count++ * kObservationDurationLowerBound),
delay_based_estimate,
/*in_alr=*/false);
result = loss_based_bandwidth_estimator.GetLossBasedResult();
}
ASSERT_EQ(result.state, LossBasedState::kIncreasing);
// The estimate increases by 1kbps.
EXPECT_EQ(result.bandwidth_estimate,
estimate_1 + DataRate::KilobitsPerSec(1));
}
// After loss based bwe backs off, the estimate is bounded during the delayed
// window.
TEST_F(LossBasedBweV2Test,