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
|
#![feature(random)]
use std::{
collections::HashSet,
random::random,
time::{Duration, Instant},
};
use log::debug;
use rtcp::{RtcpPacket, RtcpPart};
use rtp::SSRC;
pub mod rtcp;
pub mod rtp;
pub struct Session {
tp: Instant,
tc: Instant,
tn: Instant,
pmembers: usize,
members: usize,
senders: usize,
rtcp_bw: f32,
we_sent: bool,
avg_rtcp_size: f32,
initial: bool,
member_table: HashSet<SSRC>,
sender_table: HashSet<SSRC>,
}
impl Session {
/// RFC 3550, Section 6.3.1
pub fn compute_rtcp_transmission_interval(&self) -> Duration {
let n;
let c;
if self.senders * 4 < self.members {
if self.we_sent {
// Senders use a quarter of the bandwidth
c = self.avg_rtcp_size / (self.rtcp_bw * 0.25);
n = self.senders;
} else {
// Receivers use the remaining three quarters
c = self.avg_rtcp_size / (self.rtcp_bw * 0.75);
n = self.members - self.senders
}
} else {
// Equally split between members
c = self.avg_rtcp_size / self.rtcp_bw;
n = self.members;
}
let tmin = if self.initial { 2.5f32 } else { 5. };
let td = tmin.max(n as f32 * c);
let t = td * ((random::<u16>() as f32) / (u16::MAX as f32) + 0.5);
let t = t / 1.5f32.exp();
debug!("RTCP transmission interval is {t:.02}s");
Duration::from_secs_f32(t)
}
/// RFC 3550, Section 6.3.2
pub fn new() -> Self {
let mut se = Self {
tp: Instant::now(),
tc: Instant::now(),
tn: Instant::now(),
senders: 0,
pmembers: 1,
members: 1,
we_sent: false,
initial: true,
sender_table: HashSet::new(),
member_table: HashSet::new(), // TODO add own ssrc to members
rtcp_bw: 1000., // TODO set rtcp bandwidth from params
avg_rtcp_size: 1000., // TODO set to next likely rtcp packet size
};
se.tn += se.compute_rtcp_transmission_interval();
se
}
pub fn tt_expire(&mut self) {
let t = self.compute_rtcp_transmission_interval();
if self.tp + t < self.tc {
self.send_rtcp();
self.tp = self.tc;
let t = self.compute_rtcp_transmission_interval();
self.tn = self.tc + t;
if self.tp + t > self.tc {
self.tn = self.tp + t;
}
self.pmembers = self.members;
}
}
pub fn send_rtcp(&mut self) {
}
/// RFC 3550, Section 6.3.3 / 6.3.4
pub fn on_receive(&mut self, packet_raw: &[u8]) {
let packet = RtcpPacket::parse(packet_raw).unwrap(); // TODO
let bye = packet.parts.iter().find_map(|p| match p {
RtcpPart::Bye(b) => Some(b),
_ => None,
});
if let Some(bye) = bye {
for s in &bye.ssrcs {
if self.member_table.remove(s) {
self.members -= 1;
}
if self.sender_table.remove(s) {
self.senders -= 1;
}
}
let f_mem = self.members as f32 / self.pmembers as f32;
self.tn = self.tc + (self.tn - self.tc).mul_f32(f_mem);
self.tp = self.tc - (self.tc - self.tp).mul_f32(f_mem);
self.pmembers = self.members
} else {
self.avg_rtcp_size =
(1. / 16.) * packet_raw.len() as f32 + (15. / 16.) * self.avg_rtcp_size;
}
}
}
|
