rtp 0.6.8

A pure Rust implementation of RTP
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

use super::*;
use crate::codecs::*;
use crate::error::Result;

use chrono::prelude::*;
use std::time::{Duration, UNIX_EPOCH};

#[tokio::test]
async fn test_packetizer() -> Result<()> {
    let multiple_payload = Bytes::from_static(&[0; 128]);
    let g722 = Box::new(g7xx::G722Payloader {});
    let seq = Box::new(new_random_sequencer());

    //use the G722 payloader here, because it's very simple and all 0s is valid G722 data.
    let mut packetizer = new_packetizer(100, 98, 0x1234ABCD, g722, seq, 90000);
    let packets = packetizer.packetize(&multiple_payload, 2000).await?;

    if packets.len() != 2 {
        let mut packet_lengths = String::new();
        for i in 0..packets.len() {
            packet_lengths +=
                format!("Packet {} length {}\n", i, packets[i].payload.len()).as_str();
        }
        assert!(
            false,
            "Generated {} packets instead of 2\n{}",
            packets.len(),
            packet_lengths,
        );
    }
    Ok(())
}

#[tokio::test]
async fn test_packetizer_abs_send_time() -> Result<()> {
    let g722 = Box::new(g7xx::G722Payloader {});
    let sequencer = Box::new(new_fixed_sequencer(1234));

    let time_gen: Option<FnTimeGen> = Some(Arc::new(
        || -> Pin<Box<dyn Future<Output = SystemTime> + Send + 'static>> {
            Box::pin(async move {
                let loc = FixedOffset::west(5 * 60 * 60); // UTC-5
                let t = loc.ymd(1985, 6, 23).and_hms_nano(4, 0, 0, 0);
                UNIX_EPOCH
                    .checked_add(Duration::from_nanos(t.timestamp_nanos() as u64))
                    .unwrap_or(UNIX_EPOCH)
            })
        },
    ));

    //use the G722 payloader here, because it's very simple and all 0s is valid G722 data.
    let mut pktizer = PacketizerImpl {
        mtu: 100,
        payload_type: 98,
        ssrc: 0x1234ABCD,
        payloader: g722,
        sequencer,
        timestamp: 45678,
        clock_rate: 90000,
        abs_send_time: 0,
        time_gen,
    };
    pktizer.enable_abs_send_time(1);

    let payload = Bytes::from_static(&[0x11, 0x12, 0x13, 0x14]);
    let packets = pktizer.packetize(&payload, 2000).await?;

    let expected = Packet {
        header: Header {
            version: 2,
            padding: false,
            extension: true,
            marker: true,
            payload_type: 98,
            sequence_number: 1234,
            timestamp: 45678,
            ssrc: 0x1234ABCD,
            csrc: vec![],
            extension_profile: 0xBEDE,
            extensions: vec![Extension {
                id: 1,
                payload: Bytes::from_static(&[0x40, 0, 0]),
            }],
        },
        payload: Bytes::from_static(&[0x11, 0x12, 0x13, 0x14]),
    };

    if packets.len() != 1 {
        assert!(false, "Generated {} packets instead of 1", packets.len())
    }

    assert_eq!(expected, packets[0]);

    Ok(())
}

#[tokio::test]
async fn test_packetizer_timestamp_rollover_does_not_panic() -> Result<()> {
    let g722 = Box::new(g7xx::G722Payloader {});
    let seq = Box::new(new_random_sequencer());

    let payload = Bytes::from_static(&[0; 128]);
    let mut packetizer = new_packetizer(100, 98, 0x1234ABCD, g722, seq, 90000);

    packetizer.packetize(&payload, 10).await?;

    packetizer.packetize(&payload, u32::MAX).await?;

    packetizer.skip_samples(u32::MAX);

    Ok(())
}