interceptor 0.17.1

A pure Rust implementation of Pluggable RTP/RTCP processors
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

use rtcp::transport_feedbacks::transport_layer_nack::TransportLayerNack;

use super::*;
use crate::mock::mock_stream::MockStream;
use crate::stream_info::RTCPFeedback;
use crate::test::timeout_or_fail;

#[tokio::test]
async fn test_generator_interceptor() -> Result<()> {
    const INTERVAL: Duration = Duration::from_millis(10);
    let icpr: Arc<dyn Interceptor + Send + Sync> = Generator::builder()
        .with_log2_size_minus_6(0)
        .with_skip_last_n(2)
        .with_interval(INTERVAL)
        .build("")?;

    let stream = MockStream::new(
        &StreamInfo {
            ssrc: 1,
            rtcp_feedback: vec![RTCPFeedback {
                typ: "nack".to_owned(),
                ..Default::default()
            }],
            ..Default::default()
        },
        icpr,
    )
    .await;

    for seq_num in [10, 11, 12, 14, 16, 18] {
        stream
            .receive_rtp(rtp::packet::Packet {
                header: rtp::header::Header {
                    sequence_number: seq_num,
                    ..Default::default()
                },
                ..Default::default()
            })
            .await;

        let r = timeout_or_fail(Duration::from_millis(10), stream.read_rtp())
            .await
            .expect("A read packet")
            .expect("Not an error");
        assert_eq!(r.header.sequence_number, seq_num);
    }

    tokio::time::sleep(INTERVAL * 2).await; // wait for at least 2 nack packets

    // ignore the first nack, it might only contain the sequence id 13 as missing
    let _ = stream.written_rtcp().await;

    let r = timeout_or_fail(Duration::from_millis(10), stream.written_rtcp())
        .await
        .expect("Write rtcp");
    if let Some(p) = r[0].as_any().downcast_ref::<TransportLayerNack>() {
        assert_eq!(p.nacks[0].packet_id, 13);
        assert_eq!(p.nacks[0].lost_packets, 0b10); // we want packets: 13, 15 (not packet 17, because skipLastN is setReceived to 2)
    } else {
        panic!("single packet RTCP Compound Packet expected");
    }

    stream.close().await?;

    Ok(())
}