YangWX/crossdesk
1
0
Fork 0
mirror of https://github.com/kunkundi/crossdesk.git synced 2025-10-27 04:35:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

[fix] fix congestion control module

Browse Source
This commit is contained in:
dijunkun
2025-01-17 17:33:13 +08:00
parent 6e2a52e506
commit 5bbd182a3f
53 changed files with 3376 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
src/qos/send_side_bandwidth_estimation.h
View File

@@ -1,63 +1,74 @@
/*
* @Author: DI JUNKUN
* @Date: 2025-01-13
* Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
* 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.
*
* FEC and NACK added bitrate is handled outside class
*/
#ifndef _SEND_SIDE_BANDWIDTH_ESTIMATION_H_
#define _SEND_SIDE_BANDWIDTH_ESTIMATION_H_
#ifndef MODULES_CONGESTION_CONTROLLER_GOOG_CC_SEND_SIDE_BANDWIDTH_ESTIMATION_H_
#define MODULES_CONGESTION_CONTROLLER_GOOG_CC_SEND_SIDE_BANDWIDTH_ESTIMATION_H_
#include <stdint.h>
#include <cstddef>
#include <cstdint>
#include <deque>
#include <limits>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
#include "limits_base.h"
#include "network_types.h"
#include "api/transport/bandwidth_usage.h"
#include "api/transport/network_types.h"
#include "api/units/data_rate.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
namespace webrtc {
class LinkCapacityTracker {
public:
LinkCapacityTracker() = default;
~LinkCapacityTracker() = default;
// Call when a new delay-based estimate is available.
void UpdateDelayBasedEstimate(int64_t at_time, int64_t delay_based_bitrate);
void OnStartingRate(int64_t start_rate);
void OnRateUpdate(std::optional<int64_t> acknowledged, int64_t target,
int64_t at_time);
void OnRttBackoff(int64_t backoff_rate, int64_t at_time);
int64_t estimate() const;
void UpdateDelayBasedEstimate(Timestamp at_time,
DataRate delay_based_bitrate);
void OnStartingRate(DataRate start_rate);
void OnRateUpdate(std::optional<DataRate> acknowledged, DataRate target,
Timestamp at_time);
void OnRttBackoff(DataRate backoff_rate, Timestamp at_time);
DataRate estimate() const;
private:
double capacity_estimate_bps_ = 0;
int64_t last_link_capacity_update_ = INT64_T_MIN;
int64_t last_delay_based_estimate_ = INT64_T_MAX;
Timestamp last_link_capacity_update_ = Timestamp::MinusInfinity();
DataRate last_delay_based_estimate_ = DataRate::PlusInfinity();
};
class RttBasedBackoff {
public:
explicit RttBasedBackoff();
~RttBasedBackoff();
void UpdatePropagationRtt(int64_t at_time, int64_t propagation_rtt);
void UpdatePropagationRtt(Timestamp at_time, TimeDelta propagation_rtt);
bool IsRttAboveLimit() const;
bool disabled_;
int64_t configured_limit_;
TimeDelta configured_limit_;
double drop_fraction_;
int64_t drop_interval_;
int64_t bandwidth_floor_;
TimeDelta drop_interval_;
DataRate bandwidth_floor_;
public:
int64_t rtt_limit_;
int64_t last_propagation_rtt_update_;
int64_t last_propagation_rtt_;
int64_t last_packet_sent_;
TimeDelta rtt_limit_;
Timestamp last_propagation_rtt_update_;
TimeDelta last_propagation_rtt_;
Timestamp last_packet_sent_;
private:
int64_t CorrectedRtt() const;
TimeDelta CorrectedRtt() const;
};
class SendSideBandwidthEstimation {
@@ -67,112 +78,108 @@ class SendSideBandwidthEstimation {
void OnRouteChange();
int64_t target_rate() const;
DataRate target_rate() const;
// Return whether the current rtt is higher than the rtt limited configured in
// RttBasedBackoff.
bool IsRttAboveLimit() const;
uint8_t fraction_loss() const { return last_fraction_loss_; }
int64_t round_trip_time() const { return last_round_trip_time_; }
TimeDelta round_trip_time() const { return last_round_trip_time_; }
int64_t GetEstimatedLinkCapacity() const;
DataRate GetEstimatedLinkCapacity() const;
// Call periodically to update estimate.
void UpdateEstimate(int64_t at_time);
void UpdateEstimate(Timestamp at_time);
void OnSentPacket(const SentPacket& sent_packet);
void UpdatePropagationRtt(int64_t at_time, int64_t propagation_rtt);
void UpdatePropagationRtt(Timestamp at_time, TimeDelta propagation_rtt);
// Call when we receive a RTCP message with TMMBR or REMB.
void UpdateReceiverEstimate(int64_t at_time, int64_t bandwidth);
void UpdateReceiverEstimate(Timestamp at_time, DataRate bandwidth);
// Call when a new delay-based estimate is available.
void UpdateDelayBasedEstimate(int64_t at_time, int64_t bitrate);
void UpdateDelayBasedEstimate(Timestamp at_time, DataRate bitrate);
// Call when we receive a RTCP message with a ReceiveBlock.
void UpdatePacketsLost(int64_t packets_lost, int64_t number_of_packets,
int64_t at_time);
Timestamp at_time);
// Call when we receive a RTCP message with a ReceiveBlock.
void UpdateRtt(int64_t rtt, int64_t at_time);
void UpdateRtt(TimeDelta rtt, Timestamp at_time);
void SetBitrates(std::optional<int64_t> send_bitrate, int64_t min_bitrate,
int64_t max_bitrate, int64_t at_time);
void SetSendBitrate(int64_t bitrate, int64_t at_time);
void SetMinMaxBitrate(int64_t min_bitrate, int64_t max_bitrate);
void SetBitrates(std::optional<DataRate> send_bitrate, DataRate min_bitrate,
DataRate max_bitrate, Timestamp at_time);
void SetSendBitrate(DataRate bitrate, Timestamp at_time);
void SetMinMaxBitrate(DataRate min_bitrate, DataRate max_bitrate);
int GetMinBitrate() const;
void SetAcknowledgedRate(std::optional<int64_t> acknowledged_rate,
int64_t at_time);
void SetAcknowledgedRate(std::optional<DataRate> acknowledged_rate,
Timestamp at_time);
private:
friend class GoogCcStatePrinter;
enum UmaState { kNoUpdate, kFirstDone, kDone };
bool IsInStartPhase(int64_t at_time) const;
bool IsInStartPhase(Timestamp at_time) const;
void UpdateUmaStatsPacketsLost(int64_t at_time, int packets_lost);
void UpdateUmaStatsPacketsLost(Timestamp at_time, int packets_lost);
// Updates history of min bitrates.
// After this method returns min_bitrate_history_.front().second contains the
// min bitrate used during last kBweIncreaseIntervalMs.
void UpdateMinHistory(int64_t at_time);
void UpdateMinHistory(Timestamp at_time);
// Gets the upper limit for the target bitrate. This is the minimum of the
// delay based limit, the receiver limit and the loss based controller limit.
int64_t GetUpperLimit() const;
DataRate GetUpperLimit() const;
// Prints a warning if `bitrate` if sufficiently long time has past since last
// warning.
void MaybeLogLowBitrateWarning(int64_t bitrate, int64_t at_time);
// Stores an update to the event log if the loss rate has changed, the target
// has changed, or sufficient time has passed since last stored event.
void MaybeLogLossBasedEvent(int64_t at_time);
void MaybeLogLowBitrateWarning(DataRate bitrate, Timestamp at_time);
// Cap `bitrate` to [min_bitrate_configured_, max_bitrate_configured_] and
// set `current_bitrate_` to the capped value and updates the event log.
void UpdateTargetBitrate(int64_t bitrate, int64_t at_time);
void UpdateTargetBitrate(DataRate bitrate, Timestamp at_time);
// Applies lower and upper bounds to the current target rate.
// TODO(srte): This seems to be called even when limits haven't changed, that
// should be cleaned up.
void ApplyTargetLimits(int64_t at_time);
void ApplyTargetLimits(Timestamp at_time);
RttBasedBackoff rtt_backoff_;
LinkCapacityTracker link_capacity_;
std::deque<std::pair<int64_t, int64_t> > min_bitrate_history_;
std::deque<std::pair<Timestamp, DataRate> > min_bitrate_history_;
// incoming filters
int lost_packets_since_last_loss_update_;
int expected_packets_since_last_loss_update_;
std::optional<int64_t> acknowledged_rate_;
int64_t current_target_;
int64_t last_logged_target_;
int64_t min_bitrate_configured_;
int64_t max_bitrate_configured_;
int64_t last_low_bitrate_log_;
std::optional<DataRate> acknowledged_rate_;
DataRate current_target_;
DataRate last_logged_target_;
DataRate min_bitrate_configured_;
DataRate max_bitrate_configured_;
Timestamp last_low_bitrate_log_;
bool has_decreased_since_last_fraction_loss_;
int64_t last_loss_feedback_;
int64_t last_loss_packet_report_;
Timestamp last_loss_feedback_;
Timestamp last_loss_packet_report_;
uint8_t last_fraction_loss_;
uint8_t last_logged_fraction_loss_;
int64_t last_round_trip_time_;
TimeDelta last_round_trip_time_;
// The max bitrate as set by the receiver in the call. This is typically
// signalled using the REMB RTCP message and is used when we don't have any
// send side delay based estimate.
int64_t receiver_limit_;
int64_t delay_based_limit_;
int64_t time_last_decrease_;
int64_t first_report_time_;
DataRate receiver_limit_;
DataRate delay_based_limit_;
Timestamp time_last_decrease_;
Timestamp first_report_time_;
int initially_lost_packets_;
int64_t bitrate_at_2_seconds_;
DataRate bitrate_at_2_seconds_;
UmaState uma_update_state_;
UmaState uma_rtt_state_;
std::vector<bool> rampup_uma_stats_updated_;
int64_t last_rtc_event_log_;
float low_loss_threshold_;
float high_loss_threshold_;
int64_t bitrate_threshold_;
DataRate bitrate_threshold_;
bool disable_receiver_limit_caps_only_;
};
#endif
} // namespace webrtc
#endif // MODULES_CONGESTION_CONTROLLER_GOOG_CC_SEND_SIDE_BANDWIDTH_ESTIMATION_H_