1
use std::net::Ipv4Addr;
2
use std::time::Duration;
3
 
4
use str0m::change::SdpOffer;
5
use str0m::format::Codec;
6
use str0m::media::{Direction, MediaKind};
7
use str0m::{Event, RtcError};
8
 
9
mod common;
10
use common::{Peer, TestRtc, init_crypto_default, init_log, progress};
11
 
12
#[test]
13
pub fn unidirectional_r_create_media() -> Result<(), RtcError> {
14
    init_log();
15
    init_crypto_default();
16
 
17
    let mut l = TestRtc::new(Peer::Left);
18
    let mut r = TestRtc::new(Peer::Right);
19
 
20
    l.add_host_candidate((Ipv4Addr::new(1, 1, 1, 1), 1000).into());
21
    r.add_host_candidate((Ipv4Addr::new(2, 2, 2, 2), 2000).into());
22
 
23
    // The change is on the R (not sending side) with Direction::RecvOnly.
24
    let mut change = r.sdp_api();
25
    let mid = change.add_media(MediaKind::Audio, Direction::RecvOnly, None, None, None);
26
    let (offer, pending) = change.apply().unwrap();
27
 
28
    // str0m always produces a=ssrc lines, also for RecvOnly (since direction can change).
29
    // We munge the a=ssrc lines away.
30
    let mut offer = offer.to_string();
31
    let start = offer.find("a=ssrc").unwrap();
32
    offer.replace_range(start..offer.len(), "");
33
 
34
    let offer = SdpOffer::from_sdp_string(&offer).unwrap();
35
    let answer = l.rtc.sdp_api().accept_offer(offer)?;
36
    r.rtc.sdp_api().accept_answer(pending, answer)?;
37
 
38
    loop {
39
        if l.is_connected() || r.is_connected() {
40
            break;
41
        }
42
        progress(&mut l, &mut r)?;
43
    }
44
 
45
    let max = l.last.max(r.last);
46
    l.last = max;
47
    r.last = max;
48
 
49
    let params = l.params_opus();
50
    assert_eq!(params.spec().codec, Codec::Opus);
51
    let pt = params.pt();
52
 
53
    let data_a = vec![1_u8; 80];
54
 
55
    loop {
56
        let wallclock = l.start + l.duration();
57
        let time = l.duration().into();
58
        l.writer(mid)
59
            .unwrap()
60
            .write(pt, wallclock, time, data_a.clone())?;
61
 
62
        progress(&mut l, &mut r)?;
63
        progress(&mut l, &mut r)?;
64
 
65
        if l.duration() > Duration::from_secs(10) {
66
            break;
67
        }
68
    }
69
 
70
    let media_count = r
71
        .events
72
        .iter()
73
        .filter(|(_, e)| matches!(e, Event::MediaData(_)))
74
        .count();
75
 
76
    assert!(media_count > 80, "Not enough MediaData: {}", media_count);
77
 
78
    Ok(())
79
}