1
use std::time::Duration;
2
 
3
use str0m::format::Codec;
4
use str0m::media::MediaKind;
5
use str0m::rtp::{ExtensionValues, RtpWrite, Ssrc};
6
use str0m::{Event, RtcError};
7
 
8
mod common;
9
use common::{connect_l_r, init_crypto_default, init_log, progress};
10
 
11
#[test]
12
pub fn repeated() -> Result<(), RtcError> {
13
    init_log();
14
    init_crypto_default();
15
 
16
    let (mut l, mut r) = connect_l_r();
17
 
18
    let mid = "aud".into();
19
 
20
    // In this example we are not using RID to identify the stream, we are simply
21
    // using SSRC 1 as knowledge shared between sending and receiving side.
22
    let ssrc: Ssrc = 1.into();
23
 
24
    l.direct_api().declare_media(mid, MediaKind::Audio);
25
 
26
    l.direct_api().declare_stream_tx(ssrc, None, mid, None);
27
 
28
    r.direct_api().declare_media(mid, MediaKind::Audio);
29
 
30
    r.direct_api().expect_stream_rx(ssrc, None, mid, None);
31
 
32
    let max = l.last.max(r.last);
33
    l.last = max;
34
    r.last = max;
35
 
36
    let params = l.params_opus();
37
    let ssrc = l.direct_api().stream_tx_by_mid(mid, None).unwrap().ssrc();
38
    assert_eq!(params.spec().codec, Codec::Opus);
39
    let pt = params.pt();
40
 
41
    let mut write_at = l.last + Duration::from_millis(300);
42
 
43
    // Repeat the 3 a bunch of times.
44
    let mut counts: Vec<u64> = vec![0, 1, 2, 3, 2, 3, 3];
45
 
46
    loop {
47
        if l.start + l.duration() > write_at && !counts.is_empty() {
48
            write_at = l.last + Duration::from_millis(300);
49
            let wallclock = l.start + l.duration();
50
 
51
            let mut direct = l.direct_api();
52
            let stream = direct.stream_tx(&ssrc).unwrap();
53
 
54
            let count = counts.remove(0);
55
            let time = (count * 1000 + 47_000_000) as u32;
56
            let seq_no = (47_000 + count).into();
57
 
58
            let exts = ExtensionValues {
59
                audio_level: Some(-42 - count as i8),
60
                voice_activity: Some(false),
61
                ..Default::default()
62
            };
63
 
64
            stream.write_rtp(
65
                RtpWrite::new(pt, seq_no, time, wallclock, [0x01, 0x02, 0x03, 0x04]).ext_vals(exts),
66
            );
67
        }
68
 
69
        progress(&mut l, &mut r)?;
70
 
71
        if l.duration() > Duration::from_secs(30) {
72
            break;
73
        }
74
    }
75
 
76
    let packets: Vec<_> = r
77
        .events
78
        .iter()
79
        .filter_map(|(_, e)| {
80
            let Event::RtpPacket(v) = e else {
81
                return None;
82
            };
83
            Some(v)
84
        })
85
        .collect();
86
 
87
    // Should only be the 4 unique sequence numbers.
88
    assert_eq!(packets.len(), 4);
89
 
90
    let h0 = packets[0].header.clone();
91
    let h1 = packets[1].header.clone();
92
 
93
    assert_eq!(h0.sequence_number, 47000);
94
    assert_eq!(h1.sequence_number, 47001);
95
 
96
    assert_eq!(h0.timestamp, 47_000_000);
97
    assert_eq!(h1.timestamp, 47_001_000);
98
 
99
    assert_eq!(h0.ext_vals.audio_level, Some(-42));
100
    assert_eq!(h1.ext_vals.audio_level, Some(-43));
101
 
102
    assert!(!h0.marker);
103
    assert!(!h1.marker);
104
 
105
    Ok(())
106
}