str0m 0.18.0

WebRTC library in Sans-IO style
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
133

use super::Ssrc;
use super::list::private::WordSized;
use super::{FeedbackMessageType, ReportList, RtcpHeader, RtcpPacket, RtcpType};

/// A receiver report.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ReceiverReport {
    /// Sender of this feedback. Mostly irrelevant, but part of RTCP packets.
    pub sender_ssrc: Ssrc,
    /// The individual reports for received SSRC.
    pub reports: ReportList<ReceptionReport>,
}

/// An individual report of reception.
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReceptionReport {
    pub ssrc: Ssrc,
    pub fraction_lost: u8,
    pub packets_lost: u32, // 24 bit
    pub max_seq: u32,
    pub jitter: u32,
    pub last_sr_time: u32,
    pub last_sr_delay: u32,
}

impl RtcpPacket for ReceiverReport {
    fn header(&self) -> RtcpHeader {
        RtcpHeader {
            rtcp_type: RtcpType::ReceiverReport,
            feedback_message_type: FeedbackMessageType::ReceptionReport(self.reports.len() as u8),
            words_less_one: (self.length_words() - 1) as u16,
        }
    }

    fn length_words(&self) -> usize {
        // * header: 1
        // * sender SSRC
        // * reports: x 6
        1 + 1 + 6 * self.reports.len()
    }

    fn write_to(&self, buf: &mut [u8]) -> usize {
        self.header().write_to(buf);

        buf[4..8].copy_from_slice(&self.sender_ssrc.to_be_bytes());

        for (i, r) in self.reports.iter().enumerate() {
            r.write_to(&mut buf[8 + i * 24..]);
        }

        self.length_words() * 4
    }
}

impl WordSized for ReceptionReport {
    fn word_size(&self) -> usize {
        6
    }
}

impl ReceptionReport {
    pub(crate) fn write_to(&self, buf: &mut [u8]) {
        buf[0..4].copy_from_slice(&self.ssrc.to_be_bytes());
        buf[4..8].copy_from_slice(&self.packets_lost.to_be_bytes());
        buf[4] = self.fraction_lost;
        buf[8..12].copy_from_slice(&self.max_seq.to_be_bytes());
        buf[12..16].copy_from_slice(&self.jitter.to_be_bytes());
        buf[16..20].copy_from_slice(&self.last_sr_time.to_be_bytes());
        buf[20..24].copy_from_slice(&self.last_sr_delay.to_be_bytes());
    }
}

impl<'a> TryFrom<&'a [u8]> for ReceiverReport {
    type Error = &'static str;

    fn try_from(buf: &'a [u8]) -> Result<Self, Self::Error> {
        if buf.len() < 4 {
            return Err("Less than 4 bytes for ReceiverReport");
        }

        let sender_ssrc = u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]]).into();

        let mut reports = ReportList::new();
        let mut buf = &buf[4..];

        let count = buf.len() / 24;

        let max = count.min(31);

        for _ in 0..max {
            let report = buf.try_into()?;
            reports.push(report);
            buf = &buf[24..];
        }

        Ok(ReceiverReport {
            sender_ssrc,
            reports,
        })
    }
}

impl<'a> TryFrom<&'a [u8]> for ReceptionReport {
    type Error = &'static str;

    fn try_from(buf: &'a [u8]) -> Result<Self, Self::Error> {
        if buf.len() < 24 {
            return Err("Less than 24 bytes for ReceptionReport");
        }

        // Receiver report shape is here
        // https://www.rfc-editor.org/rfc/rfc3550#section-6.4.2

        let ssrc = u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]]).into();
        let fraction_lost = buf[4];
        let packets_lost = u32::from_be_bytes([0, buf[5], buf[6], buf[7]]);
        let max_seq = u32::from_be_bytes([buf[8], buf[9], buf[10], buf[11]]);
        let jitter = u32::from_be_bytes([buf[12], buf[13], buf[14], buf[15]]);
        let last_sr_time = u32::from_be_bytes([buf[16], buf[17], buf[18], buf[19]]);
        let last_sr_delay = u32::from_be_bytes([buf[20], buf[21], buf[22], buf[23]]);

        Ok(ReceptionReport {
            ssrc,
            fraction_lost,
            packets_lost,
            max_seq,
            jitter,
            last_sr_time,
            last_sr_delay,
        })
    }
}