goog_cc 0.1.3

A direct Rust port of the Google Congestion Control algorithm from WebRTC
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use super::{AlrExperimentSettings, CongestionWindowConfig, VideoRateControlConfig};

pub use crate::{
    goog_cc::{
        AlrDetectorConfig, BitrateEstimatorConfig, BweLossExperiment,
        BweSeparateAudioPacketsSettings, LossBasedBweV2Config, LossBasedControlConfig,
        ProbeControllerConfig, RobustThroughputEstimatorSettings, RttBasedBackoffConfig,
        SafeResetOnRouteChange, TrendlineEstimatorSettings,
    },
    remote_bitrate_estimator::{BweBackOffFactor, EstimateBoundedIncrease},
};

/// Current field trials for WebRTC that impact GoogCC.
///
/// These have been painstakingly extracted from the WebRTC source code.
/// Normally these field trials are enabled via bespoke string parsing, but that is very difficult to port correctly.
/// I decided to make everything type safe which doubles as documentation; ur welcome.
#[derive(Clone, Debug)]
pub struct FieldTrials {
    /// WebRTC-Bwe-RobustThroughputEstimatorSettings
    pub robust_throughput_estimator_settings: RobustThroughputEstimatorSettings,

    // Probing settings.
    /// WebRTC-Bwe-ProbingConfiguration
    pub probing_configuration: ProbeControllerConfig,

    // Use probing to recover faster after large bitrate estimate drops.
    /// WebRTC-BweRapidRecoveryExperiment
    pub rapid_recovery_experiment: bool,

    /// WebRTC-AlrDetectorParameters
    pub alr_detector_parameters: AlrDetectorConfig,

    /// WebRTC-ProbingScreenshareBwe or WebRTC-StrictPacingAndProbing (legacy?)
    pub alr_experiment_settings: AlrExperimentSettings,

    /// WebRTC-AddPacingToCongestionWindowPushback
    pub add_pacing_to_congestion_window_pushback: bool,

    /// WebRTC-CongestionWindow
    pub congestion_window: CongestionWindowConfig,

    /// WebRTC-VideoRateControl
    pub video_rate_control: VideoRateControlConfig,

    /// WebRTC-UseBaseHeavyVP8TL3RateAllocation
    pub vp8_base_heavy_tl3_alloc: bool,

    /// WebRTC-Bwe-SeparateAudioPackets
    pub separate_audio_packets: BweSeparateAudioPacketsSettings,

    /// WebRTC-Bwe-LossBasedControl
    pub loss_based_control: LossBasedControlConfig,

    /// LossBasedBweV2Config
    pub loss_based_bwe_v2: LossBasedBweV2Config,

    /// WebRTC-Bwe-MaxRttLimit
    pub max_rtt_limit: RttBasedBackoffConfig,

    /// WebRTC-Bwe-TrendlineEstimatorSettings
    pub trendline_estimator_settings: TrendlineEstimatorSettings,

    /// WebRTC-BweBackOffFactor
    pub bwe_back_off_factor: BweBackOffFactor,

    /// WebRTC-DontIncreaseDelayBasedBweInAlr
    pub no_bitrate_increase_in_alr: bool,

    /// WebRTC-Bwe-EstimateBoundedIncrease
    pub estimate_bounded_increase: EstimateBoundedIncrease,

    /// WebRTC-Bwe-MinAllocAsLowerBound
    pub min_alloc_as_lower_bound: bool,

    /// WebRTC-Bwe-IgnoreProbesLowerThanNetworkStateEstimate
    pub ignore_probes_lower_than_network_state_estimate: bool,

    /// WebRTC-Bwe-LimitProbesLowerThanThroughputEstimate
    pub limit_probes_lower_than_throughput_estimate: bool,

    /// WebRTC-Bwe-PaceAtMaxOfBweAndLowerLinkCapacity
    pub pace_at_max_of_bwe_and_lower_link_capacity: bool,

    /// WebRTC-Bwe-LimitPacingFactorByUpperLinkCapacityEstimate
    pub limit_pacing_factor_by_upper_link_capacity_estimate: bool,

    /// WebRTC-Bwe-SafeResetOnRouteChange
    pub safe_reset_on_route_change: SafeResetOnRouteChange,

    /// WebRTC-BweThroughputWindowConfig
    pub bwe_throughput_window_config: BitrateEstimatorConfig,

    /// WebRTC-BweLossExperiment
    pub loss_experiment: BweLossExperiment,

    /// WebRTC-Bwe-ReceiverLimitCapsOnly
    pub receiver_limit_caps_only: bool,
}

impl Default for FieldTrials {
    fn default() -> Self {
        Self {
            robust_throughput_estimator_settings: RobustThroughputEstimatorSettings::default(),
            probing_configuration: ProbeControllerConfig::default(),
            rapid_recovery_experiment: false,
            alr_detector_parameters: AlrDetectorConfig::default(),
            alr_experiment_settings: AlrExperimentSettings::default(),
            add_pacing_to_congestion_window_pushback: false,
            congestion_window: CongestionWindowConfig::default(),
            video_rate_control: VideoRateControlConfig::default(),
            vp8_base_heavy_tl3_alloc: false,
            separate_audio_packets: BweSeparateAudioPacketsSettings::default(),
            loss_based_control: LossBasedControlConfig::default(),
            loss_based_bwe_v2: LossBasedBweV2Config::default(),
            max_rtt_limit: RttBasedBackoffConfig::default(),
            trendline_estimator_settings: TrendlineEstimatorSettings::default(),
            bwe_back_off_factor: BweBackOffFactor::default(),
            no_bitrate_increase_in_alr: false,
            estimate_bounded_increase: EstimateBoundedIncrease::default(),
            min_alloc_as_lower_bound: true,
            ignore_probes_lower_than_network_state_estimate: true,
            limit_probes_lower_than_throughput_estimate: true,
            pace_at_max_of_bwe_and_lower_link_capacity: false,
            limit_pacing_factor_by_upper_link_capacity_estimate: false,
            safe_reset_on_route_change: SafeResetOnRouteChange::default(),
            bwe_throughput_window_config: BitrateEstimatorConfig::default(),
            loss_experiment: BweLossExperiment::default(),
            receiver_limit_caps_only: false,
        }
    }
}