zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup of constraints configuration in GoogCcNetworkController.

Browse Source 
Bug: webrtc:9887
Change-Id: Ic12cc477ae96dac0890337d3f7aa8ff031ff6687
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/126003
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Jonas Olsson <jonasolsson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27014}
This commit is contained in:
Sebastian Jansson
2019-03-07 10:57:41 +01:00
committed by Commit Bot
parent 78b7d49dca
commit dc62ae432d
2 changed files with 54 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
modules/congestion_controller/goog_cc/goog_cc_network_control.cc
View File

@ -42,21 +42,6 @@ constexpr TimeDelta kLossUpdateInterval = TimeDelta::Millis<1000>();
// overshoots from the encoder. // overshoots from the encoder.
const float kDefaultPaceMultiplier = 2.5f; const float kDefaultPaceMultiplier = 2.5f;
// Makes sure that the bitrate and the min, max values are in valid range.
static void ClampBitrates(int64_t* bitrate_bps,
int64_t* min_bitrate_bps,
int64_t* max_bitrate_bps) {
// TODO(holmer): We should make sure the default bitrates are set to 10 kbps,
// and that we don't try to set the min bitrate to 0 from any applications.
// The congestion controller should allow a min bitrate of 0.
if (*min_bitrate_bps < congestion_controller::GetMinBitrateBps())
*min_bitrate_bps = congestion_controller::GetMinBitrateBps();
if (*max_bitrate_bps > 0)
*max_bitrate_bps = std::max(*min_bitrate_bps, *max_bitrate_bps);
if (*bitrate_bps > 0)
*bitrate_bps = std::max(*min_bitrate_bps, *bitrate_bps);
}
std::vector<PacketFeedback> ReceivedPacketsFeedbackAsRtp( std::vector<PacketFeedback> ReceivedPacketsFeedbackAsRtp(
const TransportPacketsFeedback report) { const TransportPacketsFeedback report) {
std::vector<PacketFeedback> packet_feedback_vector; std::vector<PacketFeedback> packet_feedback_vector;
@ -147,54 +132,38 @@ NetworkControlUpdate GoogCcNetworkController::OnNetworkAvailability(
NetworkControlUpdate GoogCcNetworkController::OnNetworkRouteChange( NetworkControlUpdate GoogCcNetworkController::OnNetworkRouteChange(
NetworkRouteChange msg) { NetworkRouteChange msg) {
int64_t min_bitrate_bps = GetBpsOrDefault(msg.constraints.min_data_rate, 0);
int64_t max_bitrate_bps = GetBpsOrDefault(msg.constraints.max_data_rate, -1);
int64_t start_bitrate_bps =
GetBpsOrDefault(msg.constraints.starting_rate, -1);
ClampBitrates(&start_bitrate_bps, &min_bitrate_bps, &max_bitrate_bps);
if (safe_reset_on_route_change_) { if (safe_reset_on_route_change_) {
absl::optional<uint32_t> estimated_bitrate_bps; absl::optional<DataRate> estimated_bitrate;
if (safe_reset_acknowledged_rate_) { if (safe_reset_acknowledged_rate_) {
estimated_bitrate_bps = acknowledged_bitrate_estimator_->bitrate_bps(); estimated_bitrate = acknowledged_bitrate_estimator_->bitrate();
if (!estimated_bitrate_bps) if (!estimated_bitrate)
estimated_bitrate_bps = acknowledged_bitrate_estimator_->PeekBps(); estimated_bitrate = acknowledged_bitrate_estimator_->PeekRate();
} else { } else {
int32_t target_bitrate_bps; int32_t target_bitrate_bps;
uint8_t fraction_loss; uint8_t fraction_loss;
int64_t rtt_ms; int64_t rtt_ms;
bandwidth_estimation_->CurrentEstimate(&target_bitrate_bps, bandwidth_estimation_->CurrentEstimate(&target_bitrate_bps,
&fraction_loss, &rtt_ms); &fraction_loss, &rtt_ms);
estimated_bitrate_bps = target_bitrate_bps; estimated_bitrate = DataRate::bps(target_bitrate_bps);
} }
if (estimated_bitrate_bps && (!msg.constraints.starting_rate || if (estimated_bitrate) {
estimated_bitrate_bps < start_bitrate_bps)) { if (msg.constraints.starting_rate) {
start_bitrate_bps = *estimated_bitrate_bps; msg.constraints.starting_rate =
msg.constraints.starting_rate = DataRate::bps(start_bitrate_bps); std::min(*msg.constraints.starting_rate, *estimated_bitrate);
} else {
msg.constraints.starting_rate = estimated_bitrate;
}
} }
} }
acknowledged_bitrate_estimator_.reset( acknowledged_bitrate_estimator_.reset(
new AcknowledgedBitrateEstimator(key_value_config_)); new AcknowledgedBitrateEstimator(key_value_config_));
probe_bitrate_estimator_.reset(new ProbeBitrateEstimator(event_log_)); probe_bitrate_estimator_.reset(new ProbeBitrateEstimator(event_log_));
delay_based_bwe_.reset(new DelayBasedBwe(key_value_config_, event_log_));
delay_based_bwe_.reset(new DelayBasedBwe(key_value_config_, event_log_));
if (msg.constraints.starting_rate)
delay_based_bwe_->SetStartBitrate(*msg.constraints.starting_rate);
// TODO(srte): Use original values instead of converted.
delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps));
bandwidth_estimation_->OnRouteChange(); bandwidth_estimation_->OnRouteChange();
bandwidth_estimation_->SetBitrates(
msg.constraints.starting_rate, DataRate::bps(min_bitrate_bps),
msg.constraints.max_data_rate.value_or(DataRate::Infinity()),
msg.at_time);
probe_controller_->Reset(msg.at_time.ms()); probe_controller_->Reset(msg.at_time.ms());
NetworkControlUpdate update; NetworkControlUpdate update;
update.probe_cluster_configs = probe_controller_->SetBitrates( update.probe_cluster_configs = ResetConstraints(msg.constraints);
min_bitrate_bps, start_bitrate_bps, max_bitrate_bps, msg.at_time.ms());
MaybeTriggerOnNetworkChanged(&update, msg.at_time); MaybeTriggerOnNetworkChanged(&update, msg.at_time);
return update; return update;
} }
@ -204,8 +173,7 @@ NetworkControlUpdate GoogCcNetworkController::OnProcessInterval(
NetworkControlUpdate update; NetworkControlUpdate update;
if (initial_config_) { if (initial_config_) {
update.probe_cluster_configs = update.probe_cluster_configs =
UpdateBitrateConstraints(initial_config_->constraints, ResetConstraints(initial_config_->constraints);
initial_config_->constraints.starting_rate);
update.pacer_config = GetPacingRates(msg.at_time); update.pacer_config = GetPacingRates(msg.at_time);
if (initial_config_->stream_based_config.requests_alr_probing) { if (initial_config_->stream_based_config.requests_alr_probing) {
@ -327,34 +295,45 @@ NetworkControlUpdate GoogCcNetworkController::OnStreamsConfig(
NetworkControlUpdate GoogCcNetworkController::OnTargetRateConstraints( NetworkControlUpdate GoogCcNetworkController::OnTargetRateConstraints(
TargetRateConstraints constraints) { TargetRateConstraints constraints) {
NetworkControlUpdate update; NetworkControlUpdate update;
update.probe_cluster_configs = update.probe_cluster_configs = ResetConstraints(constraints);
UpdateBitrateConstraints(constraints, constraints.starting_rate);
MaybeTriggerOnNetworkChanged(&update, constraints.at_time); MaybeTriggerOnNetworkChanged(&update, constraints.at_time);
return update; return update;
} }
std::vector<ProbeClusterConfig> void GoogCcNetworkController::ClampConstraints() {
GoogCcNetworkController::UpdateBitrateConstraints( // TODO(holmer): We should make sure the default bitrates are set to 10 kbps,
TargetRateConstraints constraints, // and that we don't try to set the min bitrate to 0 from any applications.
absl::optional<DataRate> starting_rate) { // The congestion controller should allow a min bitrate of 0.
int64_t min_bitrate_bps = GetBpsOrDefault(constraints.min_data_rate, 0); min_data_rate_ =
int64_t max_bitrate_bps = GetBpsOrDefault(constraints.max_data_rate, -1); std::max(min_data_rate_, congestion_controller::GetMinBitrate());
int64_t start_bitrate_bps = GetBpsOrDefault(starting_rate, -1); if (max_data_rate_ < min_data_rate_) {
RTC_LOG(LS_WARNING) << "max bitrate smaller than min bitrate";
max_data_rate_ = min_data_rate_;
}
if (starting_rate_ && starting_rate_ < min_data_rate_) {
RTC_LOG(LS_WARNING) << "start bitrate smaller than min bitrate";
starting_rate_ = min_data_rate_;
}
}
ClampBitrates(&start_bitrate_bps, &min_bitrate_bps, &max_bitrate_bps); std::vector<ProbeClusterConfig> GoogCcNetworkController::ResetConstraints(
TargetRateConstraints new_constraints) {
min_data_rate_ = new_constraints.min_data_rate.value_or(DataRate::Zero());
max_data_rate_ =
new_constraints.max_data_rate.value_or(DataRate::PlusInfinity());
starting_rate_ = new_constraints.starting_rate;
ClampConstraints();
std::vector<ProbeClusterConfig> probes(probe_controller_->SetBitrates( bandwidth_estimation_->SetBitrates(starting_rate_, min_data_rate_,
min_bitrate_bps, start_bitrate_bps, max_bitrate_bps, max_data_rate_, new_constraints.at_time);
constraints.at_time.ms()));
bandwidth_estimation_->SetBitrates( if (starting_rate_)
starting_rate, DataRate::bps(min_bitrate_bps), delay_based_bwe_->SetStartBitrate(*starting_rate_);
constraints.max_data_rate.value_or(DataRate::Infinity()), delay_based_bwe_->SetMinBitrate(min_data_rate_);
constraints.at_time);
if (starting_rate) return probe_controller_->SetBitrates(
delay_based_bwe_->SetStartBitrate(*starting_rate); min_data_rate_.bps(), GetBpsOrDefault(starting_rate_, -1),
delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps)); max_data_rate_.bps_or(-1), new_constraints.at_time.ms());
return probes;
} }
NetworkControlUpdate GoogCcNetworkController::OnTransportLossReport( NetworkControlUpdate GoogCcNetworkController::OnTransportLossReport(

10
modules/congestion_controller/goog_cc/goog_cc_network_control.h
View File

@ -63,9 +63,9 @@ class GoogCcNetworkController : public NetworkControllerInterface {
private: private:
friend class GoogCcStatePrinter; friend class GoogCcStatePrinter;
std::vector<ProbeClusterConfig> UpdateBitrateConstraints( std::vector<ProbeClusterConfig> ResetConstraints(
TargetRateConstraints constraints, TargetRateConstraints new_constraints);
absl::optional<DataRate> starting_rate); void ClampConstraints();
void MaybeTriggerOnNetworkChanged(NetworkControlUpdate* update, void MaybeTriggerOnNetworkChanged(NetworkControlUpdate* update,
Timestamp at_time); Timestamp at_time);
PacerConfig GetPacingRates(Timestamp at_time) const; PacerConfig GetPacingRates(Timestamp at_time) const;
@ -92,6 +92,10 @@ class GoogCcNetworkController : public NetworkControllerInterface {
absl::optional<NetworkControllerConfig> initial_config_; absl::optional<NetworkControllerConfig> initial_config_;
DataRate min_data_rate_ = DataRate::Zero();
DataRate max_data_rate_ = DataRate::PlusInfinity();
absl::optional<DataRate> starting_rate_;
bool first_packet_sent_ = false; bool first_packet_sent_ = false;
Timestamp next_loss_update_ = Timestamp::MinusInfinity(); Timestamp next_loss_update_ = Timestamp::MinusInfinity();