goog_cc 0.1.0

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

pub struct IntervalBudget {
    target_rate_kbps: i64,
    max_bytes_in_budget: i64,
    bytes_remaining: i64,
    can_build_up_underuse: bool,
}

impl IntervalBudget {
    const WINDOW_MS: i64 = 500;

    pub fn new(initial_target_rate_kbps: i64, can_build_up_underuse: bool) -> Self {
        let mut this = Self {
            bytes_remaining: 0,
            can_build_up_underuse,
            target_rate_kbps: 0,
            max_bytes_in_budget: 0,
        };
        this.set_target_rate_kbps(initial_target_rate_kbps);
        this
    }

    pub fn set_target_rate_kbps(&mut self, target_rate_kbps: i64) {
        self.target_rate_kbps = target_rate_kbps;
        self.max_bytes_in_budget = (Self::WINDOW_MS * self.target_rate_kbps) / 8;
        self.bytes_remaining = std::cmp::min(
            std::cmp::max(-self.max_bytes_in_budget, self.bytes_remaining),
            self.max_bytes_in_budget,
        );
    }

    pub fn increase_budget(&mut self, delta_time_ms: i64) {
        let bytes: i64 = self.target_rate_kbps * delta_time_ms / 8;
        if self.bytes_remaining < 0 || self.can_build_up_underuse {
            // We overused last interval, compensate this interval.
            self.bytes_remaining =
                std::cmp::min(self.bytes_remaining + bytes, self.max_bytes_in_budget);
        } else {
            // If we underused last interval we can't use it this interval.
            self.bytes_remaining = std::cmp::min(bytes, self.max_bytes_in_budget);
        }
    }

    pub fn use_budget(&mut self, bytes: usize) {
        self.bytes_remaining = std::cmp::max(
            self.bytes_remaining - bytes as i64,
            -self.max_bytes_in_budget,
        );
    }

    /* unused
    pub fn bytes_remaining(&self) -> usize {
        self.bytes_remaining.try_into().unwrap_or(0)
    }
    */

    pub fn budget_ratio(&self) -> f64 {
        if self.max_bytes_in_budget == 0 {
            return 0.0;
        }
        self.bytes_remaining as f64 / self.max_bytes_in_budget as f64
    }

    /* unused
    pub fn target_rate_kbps(&self) -> i64 {
        self.target_rate_kbps
    }
    */
}