1
use std::collections::VecDeque;
2
use std::time::Duration;
3
 
4
use str0m::format::Codec;
5
use str0m::media::MediaKind;
6
use str0m::rtp::{ExtensionValues, RtpWrite, Ssrc};
7
use str0m::{Event, RtcError};
8
 
9
mod common;
10
use common::{connect_l_r, init_crypto_default, init_log, progress};
11
 
12
#[test]
13
pub fn rtx_cache_0() -> Result<(), RtcError> {
14
    init_log();
15
    init_crypto_default();
16
 
17
    let (mut l, mut r) = connect_l_r();
18
 
19
    let mid = "aud".into();
20
    let rid = "hi".into();
21
 
22
    // In this example we are using MID and RID to identify the incoming media.
23
    let ssrc_tx: Ssrc = 42.into();
24
 
25
    l.direct_api().declare_media(mid, MediaKind::Audio);
26
 
27
    l.direct_api()
28
        .declare_stream_tx(ssrc_tx, None, mid, Some(rid))
29
        //
30
        // disable RTX cache by setting 0
31
        .set_rtx_cache(0, Duration::ZERO, Some(0.15));
32
 
33
    r.direct_api()
34
        .declare_media(mid, MediaKind::Audio)
35
        .expect_rid_rx(rid);
36
 
37
    let max = l.last.max(r.last);
38
    l.last = max;
39
    r.last = max;
40
 
41
    let params = l.params_vp8();
42
    let ssrc = l.direct_api().stream_tx_by_mid(mid, None).unwrap().ssrc();
43
    assert_eq!(params.spec().codec, Codec::Vp8);
44
    let pt = params.pt();
45
 
46
    let to_write: Vec<&[u8]> = vec![
47
        // 1
48
        &[0x1, 0x2, 0x3, 0x4],
49
        // 3
50
        &[0x9, 0xa, 0xb, 0xc],
51
        // 2
52
        &[0x5, 0x6, 0x7, 0x8],
53
    ];
54
 
55
    let mut to_write: VecDeque<_> = to_write.into();
56
 
57
    let mut write_at = l.last + Duration::from_millis(300);
58
 
59
    let mut counts: Vec<u64> = vec![0, 3, 1];
60
 
61
    loop {
62
        if l.start + l.duration() > write_at {
63
            write_at = l.last + Duration::from_millis(300);
64
            if let Some(packet) = to_write.pop_front() {
65
                let wallclock = l.start + l.duration();
66
 
67
                let mut direct = l.direct_api();
68
                let stream = direct.stream_tx(&ssrc).unwrap();
69
 
70
                let count = counts.remove(0);
71
                let time = (count * 1000 + 47_000_000) as u32;
72
                let seq_no = (47_000 + count).into();
73
 
74
                let exts = ExtensionValues {
75
                    audio_level: Some(-42 - count as i8),
76
                    voice_activity: Some(false),
77
                    ..Default::default()
78
                };
79
 
80
                stream.write_rtp(RtpWrite::new(pt, seq_no, time, wallclock, packet).ext_vals(exts));
81
            }
82
        }
83
 
84
        progress(&mut l, &mut r)?;
85
 
86
        if l.duration() > Duration::from_secs(10) {
87
            break;
88
        }
89
    }
90
 
91
    let media: Vec<_> = r
92
        .events
93
        .iter()
94
        .filter_map(|(_, e)| {
95
            if let Event::RtpPacket(v) = e {
96
                Some(v)
97
            } else {
98
                None
99
            }
100
        })
101
        .collect();
102
 
103
    assert_eq!(media.len(), 3);
104
 
105
    assert!(l.media(mid).is_some());
106
    assert!(l.direct_api().stream_tx_by_mid(mid, None).is_some());
107
    l.direct_api().remove_media(mid);
108
    assert!(l.media(mid).is_none());
109
    assert!(l.direct_api().stream_tx_by_mid(mid, None).is_none());
110
 
111
    assert!(r.media(mid).is_some());
112
    assert!(r.direct_api().stream_rx_by_mid(mid, None).is_some());
113
    r.direct_api().remove_media(mid);
114
    assert!(r.media(mid).is_none());
115
    assert!(r.direct_api().stream_rx_by_mid(mid, None).is_none());
116
 
117
    Ok(())
118
}