use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use super::tests::{
assert_cast_frames, connect_test, fake_airplay, never, opts, SharedTally, Tallied,
};
use super::*;
use crate::airplay::fake_mirror::{Behaviour, FakeMirror};
use crate::airplay::MirrorOptions;
use crate::cast::fake_receiver::{FakeReceiver, Options as CastFake};
use crate::types::{AudioInfo, EncodedFrame, SinkStatus, VideoInfo, VIDEO_CLOCK_RATE};
use crate::util::time::NtpTime;
fn pattern_opts(to: Vec<String>) -> PlayOptions {
PlayOptions {
to,
size: Some(Size {
width: 320,
height: 180,
}),
encoder: Encoder::Builtin,
..opts()
}
}
fn no_io() -> GameIo {
GameIo {
stdin: Box::new(std::io::empty()),
stdout: Box::new(std::io::sink()),
approve: Box::new(|_, _| false),
}
}
type Schedule = Arc<Mutex<Vec<(u64, Instant)>>>;
struct Observed {
inner: Box<dyn Sink>,
delay: Option<Duration>,
clock: Option<crate::media::clock::SessionClock>,
log: Schedule,
}
impl Sink for Observed {
fn name(&self) -> &str {
self.inner.name()
}
fn capabilities(&self) -> &Capabilities {
self.inner.capabilities()
}
fn set_clock(&mut self, clock: crate::media::clock::SessionClock) {
self.clock = Some(clock.clone());
self.inner.set_clock(clock)
}
fn start(&mut self, v: &VideoInfo, a: Option<&AudioInfo>) -> Result<()> {
self.inner.start(v, a)
}
fn push(&mut self, f: &EncodedFrame) -> Result<SinkStatus> {
let video = f.track == TrackKind::Video;
if video {
if let Some(d) = self.delay.take() {
std::thread::sleep(d);
}
}
let r = self.inner.push(f);
if video && matches!(r, Ok(SinkStatus::Accepted)) {
let clock = self.clock.as_ref().expect("session clock");
let at = clock.instant_for(f.pts, VIDEO_CLOCK_RATE).unwrap();
self.log.lock().unwrap().push((f.pts, at));
}
r
}
fn wants_keyframe(&self) -> bool {
self.inner.wants_keyframe()
}
fn stop(&mut self) -> Result<()> {
self.inner.stop()
}
}
fn fp_to_duration(fp: u64) -> Duration {
Duration::from_nanos(((fp as u128 * 1_000_000_000) >> 32) as u64)
}
fn ntp_diff(a: u64, b: u64) -> f64 {
(a.wrapping_sub(b) as i64) as f64 / 4_294_967_296.0
}
fn gap(a: Instant, b: Instant) -> Duration {
if a > b {
a - b
} else {
b - a
}
}
#[test]
fn mixed_receivers_share_one_timeline() {
let (i0, n0) = (Instant::now(), NtpTime::now());
let c0 = crate::airplay::timing::ntp_clock(i0);
let rx = FakeReceiver::spawn(CastFake::default());
let fake = FakeMirror::start(Behaviour {
nack_after: None,
..Behaviour::default()
});
let seen_mirror = Mutex::new(None);
let (cast_log, airplay_log) = (Schedule::default(), Schedule::default());
let (cast_tally, airplay_tally) = (SharedTally::default(), SharedTally::default());
let observed = |inner, ms, log: &Schedule, tally: &SharedTally| -> Box<dyn Sink> {
let inner = Box::new(Observed {
inner,
delay: Some(Duration::from_millis(ms)),
clock: None,
log: log.clone(),
});
Tallied::boxed(inner, Some(24), tally)
};
let connect = |t: &Target, c: &CastOptions, m: &MirrorOptions| -> Result<Box<dyn Sink>> {
match t {
Target::Browser(_) => connect_test(t, c, m),
Target::Cast { addr, name } => Ok(observed(
Box::new(cast::connect(*addr, name, c)?),
80,
&cast_log,
&cast_tally,
)),
Target::AirPlay { .. } => {
*seen_mirror.lock().unwrap() = Some(m.clone());
let m = MirrorOptions {
ptp: false,
..m.clone()
};
Ok(observed(
fake_airplay(&fake, "fake-airplay", &m)?,
150,
&airplay_log,
&airplay_tally,
))
}
}
};
let o = pattern_opts(vec![rx.addr.to_string(), format!("airplay:{}", fake.addr)]);
play_with(o, no_io(), &connect, &never()).unwrap();
let m = seen_mirror.lock().unwrap().clone().unwrap();
assert_eq!(m.latency_ms, Some(DEFAULT_LATENCY_MS));
let state = rx.shutdown();
let st = state.lock().unwrap();
assert!(st.stopped, "STOP not received");
let offer = st.offer.as_ref().unwrap();
let streams = offer["offer"]["supportedStreams"].as_array().unwrap();
assert!(!streams.is_empty());
for s in streams {
assert_eq!(s["targetDelay"].as_u32(), Some(DEFAULT_LATENCY_MS), "{s:?}");
}
let r = fake.rec();
assert!(r.teardown, "TEARDOWN not received");
let video_setup = r
.setup_bodies
.iter()
.filter_map(|b| b.get("streams")?.as_array()?.first()?.get("latencyMs"))
.find_map(|v| v.as_u32());
assert_eq!(video_setup, Some(DEFAULT_LATENCY_MS));
assert!(st.streams.iter().any(|s| s.codec == "aac"), "Cast audio");
assert!(!r.audio.is_empty(), "AirPlay audio");
let cast_log = cast_log.lock().unwrap().clone();
let airplay_log = airplay_log.lock().unwrap().clone();
let (tc, ta) = (*cast_tally.lock().unwrap(), *airplay_tally.lock().unwrap());
assert_eq!((tc.video, ta.video), (24, 24), "{tc:?} {ta:?}");
assert_eq!(cast_log.len() as u64, tc.video_accepted);
assert_eq!(airplay_log.len() as u64, ta.video_accepted);
let mut common = 0;
for (pts, at) in &airplay_log {
if let Some((_, c)) = cast_log.iter().find(|(p, _)| p == pts) {
assert_eq!(at, c, "pts {pts}");
common += 1;
}
}
assert!(common >= 12, "{common} frames in common, {tc:?} {ta:?}");
let lead = fp_to_duration(crate::airplay::timing::fp_from_duration(
Duration::from_millis(DEFAULT_LATENCY_MS as u64),
));
let sent: Vec<Instant> = r
.video
.iter()
.filter(|p| p.kind == 0)
.map(|p| i0 + (fp_to_duration(p.ts - c0) - lead))
.collect();
assert_eq!(sent.len(), airplay_log.len());
for (i, (t, (_, at))) in sent.iter().zip(&airplay_log).enumerate() {
assert!(gap(*t, *at) < Duration::from_millis(1), "AirPlay frame {i}");
}
let v = st.streams.iter().find(|s| s.codec == "h264").unwrap();
assert_cast_frames(&v.frames, tc.video_accepted);
for (f, (pts, _)) in v.frames.values().zip(&cast_log) {
assert_eq!(f.rtp_timestamp, *pts as u32);
}
let (p0, _) = cast_log[0];
let offset = |pts: u64, at: Instant| -> f64 {
let secs = if at >= i0 {
(at - i0).as_secs_f64()
} else {
-(i0 - at).as_secs_f64()
};
secs - (pts as f64 - p0 as f64) / 90_000.0
};
let offsets: Vec<f64> = cast_log.iter().map(|(p, a)| offset(*p, *a)).collect();
assert!(!v.sender_reports.is_empty(), "no Sender Report");
for sr in &v.sender_reports {
let dt = (sr.rtp_timestamp.wrapping_sub(p0 as u32) as i32) as f64 / 90_000.0;
let sr_offset = ntp_diff(sr.ntp, n0.0) - dt;
let best = offsets
.iter()
.map(|o| (o - sr_offset).abs())
.fold(f64::MAX, f64::min);
assert!(best < 0.003, "Sender Report {best} s off the schedule");
}
}
#[derive(Default)]
struct Tallies {
cast: SharedTally,
airplay: SharedTally,
}
fn mixed_connector<'a>(
fake: &'a FakeMirror,
cast_limit: Option<usize>,
airplay_limit: Option<usize>,
tallies: &'a Tallies,
) -> impl Fn(&Target, &CastOptions, &MirrorOptions) -> Result<Box<dyn Sink>> + Sync + 'a {
move |t, c, m| {
Ok(match t {
Target::Browser(_) => connect_test(t, c, m)?,
Target::Cast { addr, name } => Tallied::boxed(
Box::new(cast::connect(*addr, name, c)?),
cast_limit,
&tallies.cast,
),
Target::AirPlay { .. } => Tallied::boxed(
fake_airplay(fake, "fake-airplay", m)?,
airplay_limit,
&tallies.airplay,
),
})
}
}
fn airplay_frames(fake: &FakeMirror) -> usize {
fake.rec().video.iter().filter(|p| p.kind == 0).count()
}
#[test]
fn unreachable_receiver_is_left_out() {
let rx = FakeReceiver::spawn(CastFake::default());
let fake = FakeMirror::start(Behaviour::default());
let tallies = Tallies::default();
let connect = mixed_connector(&fake, Some(10), Some(10), &tallies);
let o = pattern_opts(vec![
rx.addr.to_string(),
"cast:127.0.0.1:1".into(),
format!("airplay:{}", fake.addr),
]);
play_with(o, no_io(), &connect, &never()).unwrap();
let state = rx.shutdown();
let st = state.lock().unwrap();
assert!(st.stopped);
let v = st.streams.iter().find(|s| s.codec == "h264").unwrap();
let (tc, ta) = (
*tallies.cast.lock().unwrap(),
*tallies.airplay.lock().unwrap(),
);
assert_eq!((tc.video, ta.video), (10, 10), "{tc:?} {ta:?}");
assert_cast_frames(&v.frames, tc.video_accepted);
assert!(fake.rec().teardown);
assert_eq!(airplay_frames(&fake) as u64, ta.video_accepted, "{ta:?}");
let o = pattern_opts(vec!["cast:127.0.0.1:1".into(), "cast:127.0.0.1:2".into()]);
let e = play_with(o, no_io(), &connect, &never()).unwrap_err();
assert_eq!(e.kind(), crate::error::ErrorKind::Io, "{e}");
}
#[test]
fn airplay_receiver_leaving_does_not_stop_cast() {
let rx = FakeReceiver::spawn(CastFake::default());
let fake = FakeMirror::start(Behaviour {
close_after_packets: Some(8),
..Behaviour::default()
});
let tallies = Tallies::default();
let connect = mixed_connector(&fake, Some(45), None, &tallies);
let o = pattern_opts(vec![rx.addr.to_string(), format!("airplay:{}", fake.addr)]);
play_with(o, no_io(), &connect, &never()).unwrap();
let state = rx.shutdown();
let st = state.lock().unwrap();
assert!(st.stopped);
let v = st.streams.iter().find(|s| s.codec == "h264").unwrap();
let tc = *tallies.cast.lock().unwrap();
assert_eq!(tc.video, 45, "{tc:?}");
assert_cast_frames(&v.frames, tc.video_accepted);
assert!(airplay_frames(&fake) <= 8);
}
#[test]
fn cast_receiver_leaving_does_not_stop_airplay() {
let rx = FakeReceiver::spawn(CastFake::default());
let fake = FakeMirror::start(Behaviour::default());
let tallies = Tallies::default();
let connect = mixed_connector(&fake, None, Some(45), &tallies);
let o = pattern_opts(vec![rx.addr.to_string(), format!("airplay:{}", fake.addr)]);
let killer = std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(400));
rx.shutdown()
});
let t0 = Instant::now();
play_with(o, no_io(), &connect, &never()).unwrap();
let state = killer.join().unwrap();
assert!(t0.elapsed() >= Duration::from_millis(1400));
let ta = *tallies.airplay.lock().unwrap();
assert_eq!(ta.video, 45, "{ta:?}");
assert_eq!(airplay_frames(&fake) as u64, ta.video_accepted, "{ta:?}");
assert!(fake.rec().teardown);
let st = state.lock().unwrap();
let v = st.streams.iter().find(|s| s.codec == "h264").unwrap();
assert!(v.frames.len() < 30, "{}", v.frames.len());
}
static STOP_REQUESTED: std::sync::LazyLock<crate::util::stop::Stop> =
std::sync::LazyLock::new(crate::util::stop::Stop::new);
#[test]
fn stop_request_tears_every_receiver_down() {
let rx = FakeReceiver::spawn(CastFake::default());
let fake = FakeMirror::start(Behaviour::default());
let tallies = Tallies::default();
let connect = mixed_connector(&fake, None, None, &tallies);
let o = pattern_opts(vec![rx.addr.to_string(), format!("airplay:{}", fake.addr)]);
let stopper = std::thread::spawn(|| {
std::thread::sleep(Duration::from_millis(700));
STOP_REQUESTED.request();
Instant::now()
});
play_with(o, no_io(), &connect, &Ctx::from(STOP_REQUESTED.clone())).unwrap();
let asked = stopper.join().unwrap();
assert!(
asked.elapsed() < Duration::from_millis(1500),
"{:?}",
asked.elapsed()
);
let state = rx.shutdown();
let st = state.lock().unwrap();
assert!(st.stopped, "Cast STOP not received");
assert!(!st.streams.is_empty());
let r = fake.rec();
assert!(r.teardown, "AirPlay TEARDOWN not received");
assert!(r.video.iter().any(|p| p.kind == 0));
}
#[test]
fn budgets() {
let cast = Target::Cast {
addr: "127.0.0.1:8009".parse().unwrap(),
name: "c".into(),
};
let airplay = Target::AirPlay {
name: "a".into(),
addr: "127.0.0.1:7000".parse().unwrap(),
device: None,
};
let b = |l, t: &[Target]| shared_budget(l, t);
let both = [cast.clone(), airplay.clone()];
let d = DEFAULT_LATENCY_MS;
assert_eq!(d, 300);
assert_eq!(
b(None, &both),
Budget {
cast_ms: d,
airplay_ms: Some(d),
browser_ms: d,
session_ms: d,
}
);
assert_eq!(
b(None, std::slice::from_ref(&cast)),
Budget {
cast_ms: d,
airplay_ms: None,
browser_ms: d,
session_ms: d,
}
);
assert_eq!(
b(None, &[airplay.clone(), airplay.clone()]),
Budget {
cast_ms: d,
airplay_ms: None,
browser_ms: BROWSER_LATENCY_MS,
session_ms: d,
}
);
assert_eq!(
b(Some(120), &both),
Budget {
cast_ms: 120,
airplay_ms: Some(120),
browser_ms: 120,
session_ms: 120,
}
);
let browser = Target::Browser(Box::default());
let only = b(None, &[browser.clone(), browser.clone()]);
assert_eq!(
(only.browser_ms, only.session_ms),
(BROWSER_LATENCY_MS, BROWSER_LATENCY_MS)
);
let mixed = b(None, &[browser.clone(), cast.clone()]);
assert_eq!((mixed.browser_ms, mixed.session_ms), (d, d));
let mixed = b(None, &[browser, airplay.clone()]);
assert_eq!(
(mixed.browser_ms, mixed.session_ms),
(BROWSER_LATENCY_MS, d)
);
assert_eq!(b(Some(9000), &[]).session_ms, 2000);
assert_eq!(b(Some(1), &both).cast_ms, 5);
assert_eq!(b(Some(9000), &both).airplay_ms, Some(2000));
}