rtc_rtcp/transport_feedbacks/transport_layer_nack/
mod.rs

1#[cfg(test)]
2mod transport_layer_nack_test;
3
4use crate::{header::*, packet::*, util::*};
5use shared::{
6    error::{Error, Result},
7    marshal::{Marshal, MarshalSize, Unmarshal},
8};
9
10use bytes::{Buf, BufMut};
11use std::any::Any;
12use std::fmt;
13
14/// PacketBitmap shouldn't be used like a normal integral,
15/// so it's type is masked here. Access it with PacketList().
16type PacketBitmap = u16;
17
18/// NackPair is a wire-representation of a collection of
19/// Lost RTP packets
20#[derive(Debug, PartialEq, Eq, Default, Clone, Copy)]
21pub struct NackPair {
22    /// ID of lost packets
23    pub packet_id: u16,
24    /// Bitmask of following lost packets
25    pub lost_packets: PacketBitmap,
26}
27
28pub struct NackIterator {
29    packet_id: u16,
30    bitfield: PacketBitmap,
31    has_yielded_packet_id: bool,
32}
33
34impl Iterator for NackIterator {
35    type Item = u16;
36
37    fn next(&mut self) -> Option<Self::Item> {
38        if !self.has_yielded_packet_id {
39            self.has_yielded_packet_id = true;
40
41            Some(self.packet_id)
42        } else {
43            let mut i = 0;
44
45            while self.bitfield != 0 {
46                if (self.bitfield & (1 << i)) != 0 {
47                    self.bitfield &= !(1 << i);
48
49                    return Some(self.packet_id.wrapping_add(i + 1));
50                }
51
52                i += 1;
53            }
54
55            None
56        }
57    }
58}
59
60impl NackPair {
61    pub fn new(seq: u16) -> Self {
62        Self {
63            packet_id: seq,
64            lost_packets: Default::default(),
65        }
66    }
67
68    /// PacketList returns a list of Nack'd packets that's referenced by a NackPair
69    pub fn packet_list(&self) -> Vec<u16> {
70        self.into_iter().collect()
71    }
72
73    pub fn range<F>(&self, f: F)
74    where
75        F: Fn(u16) -> bool,
76    {
77        for packet_id in self.into_iter() {
78            if !f(packet_id) {
79                return;
80            }
81        }
82    }
83}
84
85/// Create an iterator over all the packet sequence numbers expressed by this NACK pair.
86impl IntoIterator for NackPair {
87    type Item = u16;
88
89    type IntoIter = NackIterator;
90
91    fn into_iter(self) -> Self::IntoIter {
92        NackIterator {
93            packet_id: self.packet_id,
94            bitfield: self.lost_packets,
95            has_yielded_packet_id: false,
96        }
97    }
98}
99
100const TLN_LENGTH: usize = 2;
101const NACK_OFFSET: usize = 8;
102
103// The TransportLayerNack packet informs the encoder about the loss of a transport packet
104/// ## Specifications
105///
106/// * [RFC 4585 §6.2.1]
107///
108/// [RFC 4585 §6.2.1]: https://tools.ietf.org/html/rfc4585#section-6.2.1
109#[derive(Debug, PartialEq, Eq, Default, Clone)]
110pub struct TransportLayerNack {
111    /// SSRC of sender
112    pub sender_ssrc: u32,
113    /// SSRC of the media source
114    pub media_ssrc: u32,
115
116    pub nacks: Vec<NackPair>,
117}
118
119impl fmt::Display for TransportLayerNack {
120    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
121        let mut out = format!("TransportLayerNack from {:x}\n", self.sender_ssrc);
122        out += format!("\tMedia Ssrc {:x}\n", self.media_ssrc).as_str();
123        out += "\tID\tLostPackets\n";
124        for nack in &self.nacks {
125            out += format!("\t{}\t{:b}\n", nack.packet_id, nack.lost_packets).as_str();
126        }
127        write!(f, "{out}")
128    }
129}
130
131impl Packet for TransportLayerNack {
132    /// returns the Header associated with this packet.
133    fn header(&self) -> Header {
134        Header {
135            padding: get_padding_size(self.raw_size()) != 0,
136            count: FORMAT_TLN,
137            packet_type: PacketType::TransportSpecificFeedback,
138            length: ((self.marshal_size() / 4) - 1) as u16,
139        }
140    }
141
142    /// destination_ssrc returns an array of SSRC values that this packet refers to.
143    fn destination_ssrc(&self) -> Vec<u32> {
144        vec![self.media_ssrc]
145    }
146
147    fn raw_size(&self) -> usize {
148        HEADER_LENGTH + NACK_OFFSET + self.nacks.len() * 4
149    }
150
151    fn as_any(&self) -> &dyn Any {
152        self
153    }
154
155    fn equal(&self, other: &dyn Packet) -> bool {
156        other.as_any().downcast_ref::<TransportLayerNack>() == Some(self)
157    }
158
159    fn cloned(&self) -> Box<dyn Packet> {
160        Box::new(self.clone())
161    }
162}
163
164impl MarshalSize for TransportLayerNack {
165    fn marshal_size(&self) -> usize {
166        let l = self.raw_size();
167        // align to 32-bit boundary
168        l + get_padding_size(l)
169    }
170}
171
172impl Marshal for TransportLayerNack {
173    /// Marshal encodes the packet in binary.
174    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
175        if self.nacks.len() + TLN_LENGTH > u8::MAX as usize {
176            return Err(Error::TooManyReports);
177        }
178        if buf.remaining_mut() < self.marshal_size() {
179            return Err(Error::BufferTooShort);
180        }
181
182        let h = self.header();
183        let n = h.marshal_to(buf)?;
184        buf = &mut buf[n..];
185
186        buf.put_u32(self.sender_ssrc);
187        buf.put_u32(self.media_ssrc);
188
189        for i in 0..self.nacks.len() {
190            buf.put_u16(self.nacks[i].packet_id);
191            buf.put_u16(self.nacks[i].lost_packets);
192        }
193
194        if h.padding {
195            put_padding(buf, self.raw_size());
196        }
197
198        Ok(self.marshal_size())
199    }
200}
201
202impl Unmarshal for TransportLayerNack {
203    /// Unmarshal decodes the ReceptionReport from binary
204    fn unmarshal<B>(raw_packet: &mut B) -> Result<Self>
205    where
206        Self: Sized,
207        B: Buf,
208    {
209        let raw_packet_len = raw_packet.remaining();
210        if raw_packet_len < (HEADER_LENGTH + SSRC_LENGTH) {
211            return Err(Error::PacketTooShort);
212        }
213
214        let h = Header::unmarshal(raw_packet)?;
215
216        if raw_packet_len < (HEADER_LENGTH + (4 * h.length) as usize) {
217            return Err(Error::PacketTooShort);
218        }
219
220        if h.packet_type != PacketType::TransportSpecificFeedback || h.count != FORMAT_TLN {
221            return Err(Error::WrongType);
222        }
223
224        let sender_ssrc = raw_packet.get_u32();
225        let media_ssrc = raw_packet.get_u32();
226
227        let mut nacks = vec![];
228        for _i in 0..(h.length as i32 - NACK_OFFSET as i32 / 4) {
229            nacks.push(NackPair {
230                packet_id: raw_packet.get_u16(),
231                lost_packets: raw_packet.get_u16(),
232            });
233        }
234
235        if
236        /*h.padding &&*/
237        raw_packet.has_remaining() {
238            raw_packet.advance(raw_packet.remaining());
239        }
240
241        Ok(TransportLayerNack {
242            sender_ssrc,
243            media_ssrc,
244            nacks,
245        })
246    }
247}
248
249pub fn nack_pairs_from_sequence_numbers(seq_nos: &[u16]) -> Vec<NackPair> {
250    if seq_nos.is_empty() {
251        return vec![];
252    }
253
254    let mut nack_pair = NackPair::new(seq_nos[0]);
255    let mut pairs = vec![];
256
257    for &seq in seq_nos.iter().skip(1) {
258        if seq == nack_pair.packet_id {
259            continue;
260        }
261        if seq <= nack_pair.packet_id || seq > nack_pair.packet_id.saturating_add(16) {
262            pairs.push(nack_pair);
263            nack_pair = NackPair::new(seq);
264            continue;
265        }
266
267        // Subtraction here is safe because the above checks that seqnum > nack_pair.packet_id.
268        nack_pair.lost_packets |= 1 << (seq - nack_pair.packet_id - 1);
269    }
270
271    pairs.push(nack_pair);
272
273    pairs
274}
rtc_rtcp/transport_feedbacks/transport_layer_nack/mod.rs

rtc_rtcp/transport_feedbacks/transport_layer_nack/
mod.rs
