1
use std::collections::VecDeque;
2
use std::time::{Duration, Instant};
3
 
4
use str0m::format::Codec;
5
use str0m::media::MediaKind;
6
use str0m::rtp::{ExtensionValues, RtpWrite, Ssrc};
7
use str0m::{Event, Rtc, RtcError};
8
 
9
mod common;
10
use common::{connect_l_r_with_rtc, init_crypto_default, init_log, progress};
11
 
12
#[test]
13
pub fn audio_start_of_talk_spurt() -> Result<(), RtcError> {
14
    init_log();
15
    init_crypto_default();
16
 
17
    let now = Instant::now();
18
    let rtc1 = Rtc::builder().set_rtp_mode(true).build(now);
19
    let rtc2 = Rtc::builder().set_reordering_size_audio(0).build(now);
20
 
21
    let (mut l, mut r) = connect_l_r_with_rtc(rtc1, rtc2);
22
 
23
    let mid = "audio".into();
24
    let ssrc_tx: Ssrc = 1337.into();
25
 
26
    l.direct_api().declare_media(mid, MediaKind::Audio);
27
    l.direct_api().declare_stream_tx(ssrc_tx, None, mid, None);
28
    r.direct_api().declare_media(mid, MediaKind::Audio);
29
 
30
    let max = l.last.max(r.last);
31
    l.last = max;
32
    r.last = max;
33
 
34
    let params = l.params_opus();
35
    let ssrc = l.direct_api().stream_tx_by_mid(mid, None).unwrap().ssrc();
36
    assert_eq!(params.spec().codec, Codec::Opus);
37
    let pt = params.pt();
38
 
39
    let to_write: Vec<&[u8]> = vec![
40
        // 1
41
        &[0x1, 0x2, 0x3, 0x4],
42
        // 3
43
        &[0x9, 0xa, 0xb, 0xc],
44
        // 2
45
        &[0x5, 0x6, 0x7, 0x8],
46
    ];
47
 
48
    let mut to_write: VecDeque<_> = to_write.into();
49
 
50
    let mut write_at = l.last + Duration::from_millis(300);
51
 
52
    let mut counts: Vec<u64> = vec![0, 3, 1];
53
 
54
    loop {
55
        if l.start + l.duration() > write_at {
56
            write_at = l.last + Duration::from_millis(300);
57
            if let Some(packet) = to_write.pop_front() {
58
                let wallclock = l.start + l.duration();
59
 
60
                let mut direct = l.direct_api();
61
                let stream = direct.stream_tx(&ssrc).unwrap();
62
 
63
                let count = counts.remove(0);
64
                let time = (count * 1000 + 47_000_000) as u32;
65
                let seq_no = (47_000 + count).into();
66
 
67
                let exts = ExtensionValues {
68
                    audio_level: Some(-42 - count as i8),
69
                    voice_activity: Some(false),
70
                    ..Default::default()
71
                };
72
 
73
                stream.write_rtp(
74
                    RtpWrite::new(pt, seq_no, time, wallclock, packet)
75
                        .marker(*seq_no % 2 == 0)
76
                        .ext_vals(exts),
77
                );
78
            }
79
        }
80
 
81
        progress(&mut l, &mut r)?;
82
 
83
        if l.duration() > Duration::from_secs(10) {
84
            break;
85
        }
86
    }
87
 
88
    let media: Vec<_> = r
89
        .events
90
        .iter()
91
        .filter_map(|(_, e)| {
92
            if let Event::MediaData(v) = e {
93
                Some(v)
94
            } else {
95
                None
96
            }
97
        })
98
        .collect();
99
 
100
    for m in media {
101
        assert!(m.audio_start_of_talk_spurt == (**m.seq_range.start() % 2 == 0));
102
    }
103
 
104
    Ok(())
105
}