use std::collections::VecDeque;
use std::io::{Read, Write};
use std::net::{IpAddr, SocketAddr, TcpStream, UdpSocket};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Condvar, Mutex, MutexGuard};
use std::thread::JoinHandle;
use std::time::{Duration, Instant};
use crate::airplay::audio::{
alac_verbatim, sync_ntp, sync_ptp, AudioCipher, Packetizer, Redundancy, ALAC_FRAME_SAMPLES,
SAMPLE_RATE,
};
use crate::airplay::keys;
use crate::airplay::legacy_pair::{self, Connected};
use crate::airplay::mirror::{self, avcc_record, codec_header, frame_payload, VideoCipher};
use crate::airplay::pair::{self, SecureClient};
use crate::airplay::policy::{self, bit};
use crate::airplay::secure::SecureStream;
use crate::airplay::session::{
lock_control, ControlStream, MirrorOptions, Session, SetupError, DEFAULT_TIMEOUT,
STOP_TEARDOWN_TIMEOUT,
};
use crate::airplay::setup::AudioCodecId;
use crate::airplay::timing::{
anchor_from_headers, fp_from_duration, fp_to_ns, ntp_clock, Timeline, NTP_EPOCH_OFFSET_FP,
};
use crate::error::{Error, Result};
use crate::media::clock::{SessionClock, SinkClock, Tolerance};
use crate::media::h264::{self, AvcConfig};
use crate::types::{
AudioCodec, AudioFamily, AudioFormat, AudioInfo, Capabilities, EncodedFrame, Sink, SinkStatus,
TrackKind, VideoCodec, VideoInfo, VIDEO_CLOCK_RATE,
};
use crate::util::ratio::Ratio;
use crate::util::time::ticks_to_duration;
pub const MAX_LATENESS: Duration = Duration::from_millis(100);
pub const MAX_EARLY: Duration = Duration::from_secs(1);
pub const FEEDBACK_INTERVAL: Duration = Duration::from_secs(2);
pub const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(1);
pub const SYNC_INTERVAL: Duration = Duration::from_secs(1);
const FRAME_WRITE_TIMEOUT: Duration = Duration::from_secs(2);
const CODEC_WRITE_TIMEOUT: Duration = Duration::from_secs(1);
const HEARTBEAT_WRITE_TIMEOUT: Duration = Duration::from_secs(5);
const STOP_DRAIN: Duration = Duration::from_millis(500);
const STOP_JOIN: Duration = Duration::from_secs(1);
const WRITE_FAILURE_GRACE: Duration = Duration::from_millis(250);
const MAX_QUEUED: usize = 32;
const MAX_QUEUED_BYTES: usize = 8 << 20;
const CLOCK_SHIFT_TOLERANCE: Duration = Duration::from_millis(1);
const MAX_STALE_AT_START: u32 = 128;
const BURST_PACKETS: u32 = 12;
const BURST_WINDOW: Duration = Duration::from_millis(5);
const MAX_BITRATE_KBPS: u32 = 12_000;
pub type SecureMirrorSink = MirrorSink<SecureStream<TcpStream>>;
pub fn connect_mirror(
target: &pair::Target,
opts: &MirrorOptions,
storage: &crate::storage::Storage,
) -> Result<AnyMirrorSink> {
let mut store = crate::airplay::credentials::Store::open(storage)?;
let name = target.label();
match legacy_pair::connect(target, &mut store)? {
Connected::Hap(control) => {
let mut first = Some(*control);
connect_with(name, opts, || {
let control = match first.take() {
Some(c) => c,
None => pair::connect(target, &store)?,
};
let secret = control.shared.secret().to_vec();
let client: SecureClient = control.client;
Ok((client, control.addr, secret, true))
})
.map(AnyMirrorSink::Hap)
}
Connected::Legacy {
client,
addr,
secret,
} => {
warn!("airplay: {name}: legacy profile (untested on hardware)");
let mut first = Some((client, addr, secret));
connect_with(name, opts, || match first.take() {
Some((client, addr, secret)) => Ok((client, addr, secret, false)),
None => Err(Error::protocol("airplay: legacy session cannot be retried")),
})
.map(AnyMirrorSink::Legacy)
}
}
}
pub enum AnyMirrorSink {
Hap(SecureMirrorSink),
Legacy(MirrorSink<TcpStream>),
}
macro_rules! any {
($self:ident, $s:ident => $e:expr) => {
match $self {
AnyMirrorSink::Hap($s) => $e,
AnyMirrorSink::Legacy($s) => $e,
}
};
}
impl Sink for AnyMirrorSink {
fn name(&self) -> &str {
any!(self, s => s.name())
}
fn capabilities(&self) -> &Capabilities {
any!(self, s => s.capabilities())
}
fn set_clock(&mut self, clock: SessionClock) {
any!(self, s => s.set_clock(clock))
}
fn start(&mut self, video: &VideoInfo, audio: Option<&AudioInfo>) -> Result<()> {
any!(self, s => s.start(video, audio))
}
fn push(&mut self, frame: &EncodedFrame) -> Result<SinkStatus> {
any!(self, s => s.push(frame))
}
fn wants_keyframe(&self) -> bool {
any!(self, s => s.wants_keyframe())
}
fn stop(&mut self) -> Result<()> {
any!(self, s => s.stop())
}
}
pub type Fresh<S> = (crate::net::rtsp::RtspClient<S>, SocketAddr, Vec<u8>, bool);
pub fn connect_with<S: ControlStream>(
name: String,
opts: &MirrorOptions,
mut connect: impl FnMut() -> Result<Fresh<S>>,
) -> Result<MirrorSink<S>> {
let mut opts = opts.clone();
loop {
let (client, peer, secret, hap) = connect()?;
match Session::establish(client, peer, secret, hap, &opts) {
Ok(s) => return Ok(MirrorSink::new(name, s, &opts)),
Err(SetupError::PtpFailed(e)) if opts.ptp => {
warn!("airplay: PTP setup failed ({e}); retrying with NTP");
opts.ptp = false;
}
Err(e) => return Err(e.into_error()),
}
}
}
const PRIVATE_CLOCK: Tolerance = Tolerance {
late: MAX_LATENESS,
early: MAX_EARLY,
};
fn capture_instant(clock: &SinkClock, pts: u64, rate: u32, now: Instant) -> Instant {
clock.instant(pts, rate, now)
}
enum Item {
Codec(Vec<u8>),
Frame {
payload: Vec<u8>,
ts: u64,
idr: bool,
},
}
impl Item {
fn len(&self) -> usize {
match self {
Item::Codec(p) => p.len(),
Item::Frame { payload, .. } => payload.len(),
}
}
}
#[derive(Default)]
struct Queue {
items: VecDeque<Item>,
bytes: usize,
closed: bool,
drain_until: Option<Instant>,
}
struct Shared {
queue: Mutex<Queue>,
cond: Condvar,
finished: AtomicBool,
failed: Mutex<Option<Error>>,
stopping: AtomicBool,
first_frame_sent: AtomicBool,
need_key: AtomicBool,
last_answer: Mutex<Instant>,
}
impl Shared {
fn queue(&self) -> MutexGuard<'_, Queue> {
self.queue.lock().unwrap_or_else(|e| e.into_inner())
}
fn fail(&self, e: Error) {
if self.stopping.load(Ordering::Acquire) {
debug!("airplay: after stop: {e}");
return;
}
debug!("airplay: {e}");
let mut f = self.failed.lock().unwrap_or_else(|e| e.into_inner());
f.get_or_insert(e);
}
fn take_failure(&self) -> Option<Error> {
self.failed.lock().unwrap_or_else(|e| e.into_inner()).take()
}
fn answered(&self) {
*self.last_answer.lock().unwrap_or_else(|e| e.into_inner()) = Instant::now();
}
fn silent_for(&self) -> Duration {
self.last_answer
.lock()
.unwrap_or_else(|e| e.into_inner())
.elapsed()
}
}
fn write_packet(sock: &mut TcpStream, bytes: &[u8], timeout: Duration) -> Result<()> {
let _ = sock.set_write_timeout(Some(timeout));
sock.write_all(bytes)
.map_err(|e| Error::io("airplay: video data write", e))
}
enum Next {
Item(Item),
Heartbeat,
Done,
}
fn writer_loop(shared: &Shared, mut sock: TcpStream, mut cipher: VideoCipher, timeline: Timeline) {
let mut next_heartbeat: Option<Instant> = None;
let mut frames = 0u64;
loop {
let next = {
let mut q = shared.queue();
loop {
if q.closed && q.drain_until.is_some_and(|t| Instant::now() >= t) {
if !q.items.is_empty() {
debug!(
"airplay: dropping {} queued video packets at stop",
q.items.len()
);
}
q.items.clear();
q.bytes = 0;
}
if let Some(it) = q.items.pop_front() {
q.bytes -= it.len();
break Next::Item(it);
}
if q.closed {
break Next::Done;
}
let now = Instant::now();
match next_heartbeat {
Some(at) if now >= at => break Next::Heartbeat,
Some(at) => {
q = shared
.cond
.wait_timeout(q, at - now)
.map(|(g, _)| g)
.unwrap_or_else(|e| e.into_inner().0);
}
None => q = shared.cond.wait(q).unwrap_or_else(|e| e.into_inner()),
}
}
};
let r = match next {
Next::Done => return,
Next::Heartbeat => {
next_heartbeat = Some(Instant::now() + HEARTBEAT_INTERVAL);
trace!("airplay: heartbeat");
write_packet(&mut sock, &mirror::heartbeat(), HEARTBEAT_WRITE_TIMEOUT)
}
Next::Item(Item::Codec(p)) => {
debug!("airplay: codec packet ({} bytes)", p.len());
write_packet(&mut sock, &p, CODEC_WRITE_TIMEOUT)
}
Next::Item(Item::Frame { payload, ts, idr }) => cipher
.frame_packet(payload, ts, idr, timeline.timeline_id())
.and_then(|pkt| {
write_packet(&mut sock, &pkt, FRAME_WRITE_TIMEOUT)?;
frames += 1;
if frames == 1 {
debug!("airplay: first video frame sent ({} bytes)", pkt.len());
shared.first_frame_sent.store(true, Ordering::Release);
next_heartbeat = Some(Instant::now() + HEARTBEAT_INTERVAL);
}
Ok(())
}),
};
if let Err(e) = r {
let until = Instant::now() + WRITE_FAILURE_GRACE;
while !shared.finished.load(Ordering::Acquire) && Instant::now() < until {
std::thread::sleep(Duration::from_millis(5));
}
if !shared.finished.load(Ordering::Acquire) {
shared.fail(e);
}
let mut q = shared.queue();
q.items.clear();
q.bytes = 0;
q.closed = true;
return;
}
}
}
struct VideoState {
length_size: usize,
sps: Vec<u8>,
pps: Vec<u8>,
width: u32,
height: u32,
need_codec: bool,
last_ts: Option<u64>,
lead: u64,
}
impl VideoState {
fn new(video: &VideoInfo, lead_ms: u32) -> Result<VideoState> {
if video.codec != VideoCodec::H264 {
return Err(Error::unsupported(
"airplay: only H.264 mirroring is implemented",
));
}
let cfg = AvcConfig::parse(&video.avcc)?;
let sps = cfg
.sps
.first()
.cloned()
.ok_or_else(|| Error::malformed("airplay: avcC without SPS"))?;
let pps = cfg
.pps
.first()
.cloned()
.ok_or_else(|| Error::malformed("airplay: avcC without PPS"))?;
let mut v = VideoState {
length_size: cfg.length_size as usize,
sps: Vec::new(),
pps,
width: video.width,
height: video.height,
need_codec: true,
last_ts: None,
lead: fp_from_duration(Duration::from_millis(lead_ms as u64)),
};
v.set_sps(sps);
Ok(v)
}
fn set_sps(&mut self, sps: Vec<u8>) {
if let Ok(s) = h264::parse_sps(&sps) {
if s.width > 0 && s.height > 0 {
self.width = s.width;
self.height = s.height;
}
}
self.sps = sps;
}
fn timestamp(&mut self, t: u64) -> u64 {
let ts = match self.last_ts {
Some(prev) if t <= prev => prev + 1,
_ => t,
};
self.last_ts = Some(ts);
ts
}
}
struct AudioState {
channels: u8,
packetizer: Arc<Mutex<Packetizer>>,
data: UdpSocket,
control: UdpSocket,
rtcp: SocketAddr,
lead: Duration,
lead_samples: u32,
started: bool,
stale: u32,
offset: u32,
last_pts: Option<u64>,
last_capture: Option<Instant>,
last_sync: Option<Instant>,
first_sync: bool,
window: (Instant, u32),
frames: u64,
}
fn lock_pk(p: &Mutex<Packetizer>) -> MutexGuard<'_, Packetizer> {
p.lock().unwrap_or_else(|e| e.into_inner())
}
impl AudioState {
fn pace(&mut self) {
let now = Instant::now();
if now.duration_since(self.window.0) >= BURST_WINDOW {
self.window = (now, 0);
}
if self.window.1 >= BURST_PACKETS {
let until = self.window.0 + BURST_WINDOW;
if let Some(d) = until.checked_duration_since(now) {
std::thread::sleep(d);
}
self.window = (Instant::now(), 0);
}
self.window.1 += 1;
}
fn send_sync(&mut self, timeline: &Timeline, rtp_now: u32, t: Instant) {
let first = self.first_sync;
self.first_sync = false;
let play = rtp_now.wrapping_sub(self.lead_samples);
let pkt = match timeline {
Timeline::Ptp(c) => sync_ptp(first, play, fp_to_ns(c.at(t)), c.timeline()).to_vec(),
Timeline::Ntp => sync_ntp(
first,
play,
ntp_clock(t).wrapping_add(NTP_EPOCH_OFFSET_FP),
rtp_now,
)
.to_vec(),
};
if first {
debug!("airplay: first audio sync (rtp {rtp_now}, play {play})");
}
if let Err(e) = self.control.send_to(&pkt, self.rtcp) {
debug!("airplay: sync packet: {e}");
}
self.last_sync = Some(Instant::now());
}
fn push(
&mut self,
frame: &EncodedFrame,
clock: &SinkClock,
timeline: &Timeline,
) -> Result<SinkStatus> {
let now = Instant::now();
let capture = capture_instant(clock, frame.pts, SAMPLE_RATE, now);
if !self.started {
if capture + self.lead <= now + Duration::from_millis(5) {
self.stale += 1;
if self.stale >= MAX_STALE_AT_START {
return Err(Error::protocol(
"airplay: audio frames keep arriving too late to play",
));
}
return Ok(SinkStatus::Dropped);
}
self.started = true;
self.offset = ALAC_FRAME_SAMPLES.wrapping_sub(frame.pts as u32);
}
let samples = (frame.data.len() / (2 * self.channels as usize)) as u32;
if let (Some(last), Some(last_capture)) = (self.last_pts, self.last_capture) {
if frame.pts < last {
let last_rtp = (last as u32).wrapping_add(self.offset);
self.offset = last_rtp
.wrapping_add(ALAC_FRAME_SAMPLES)
.wrapping_sub(frame.pts as u32);
self.first_sync = true;
self.last_sync = None;
} else {
let predicted = last_capture + ticks_to_duration(frame.pts - last, SAMPLE_RATE);
if capture > predicted + CLOCK_SHIFT_TOLERANCE {
let gap = ((capture - predicted).as_secs_f64() * SAMPLE_RATE as f64).round();
debug!("airplay: audio clock moved {gap} samples ahead; RTP gap");
self.offset = self.offset.wrapping_add(gap as u32);
} else if capture + CLOCK_SHIFT_TOLERANCE < predicted {
debug!("airplay: audio clock moved back; new sync mapping");
self.first_sync = true;
self.last_sync = None;
}
}
}
self.last_pts = Some(frame.pts);
self.last_capture = Some(capture);
let rtp = (frame.pts as u32).wrapping_add(self.offset);
let alac = alac_verbatim(&frame.data, self.channels)?;
let due = self
.last_sync
.is_none_or(|t| now.duration_since(t) >= SYNC_INTERVAL);
if due {
self.send_sync(timeline, rtp, capture);
}
let packets = lock_pk(&self.packetizer).frame(rtp, &alac)?;
for p in packets {
self.pace();
if let Err(e) = self.data.send(&p) {
debug!("airplay: audio send: {e}");
}
}
self.frames += 1;
if self.frames == 1 {
debug!("airplay: first audio frame sent (rtp {rtp}, {samples} samples)");
}
Ok(SinkStatus::Accepted)
}
}
#[derive(Default)]
struct Diag {
origin: Option<(Instant, Duration)>,
since: Option<Instant>,
late: [(i64, i64); 2],
headroom: [i64; 2],
count: [u64; 2],
}
const DIAG_INTERVAL: Duration = Duration::from_secs(5);
impl Diag {
fn note(&mut self, track: usize, media: Duration, now: Instant, deadline: Instant) {
let (t0, m0) = *self.origin.get_or_insert((now, media));
let since = *self.since.get_or_insert(now);
let ms = |a: Instant, b: Instant| -> i64 {
if a >= b {
(a - b).as_millis() as i64
} else {
-((b - a).as_millis() as i64)
}
};
let due = if media >= m0 {
t0 + (media - m0)
} else {
t0.checked_sub(m0 - media).unwrap_or(t0)
};
let late = ms(now, due);
let head = ms(deadline, now);
if self.count[track] == 0 {
self.late[track] = (late, late);
self.headroom[track] = head;
} else {
let l = &mut self.late[track];
*l = (l.0.min(late), l.1.max(late));
self.headroom[track] = self.headroom[track].min(head);
}
self.count[track] += 1;
if now.duration_since(since) >= DIAG_INTERVAL {
debug!(
"airplay: timing: video {} frames late {}..{} ms headroom >= {} ms; \
audio {} frames late {}..{} ms headroom >= {} ms",
self.count[0],
self.late[0].0,
self.late[0].1,
self.headroom[0],
self.count[1],
self.late[1].0,
self.late[1].1,
self.headroom[1]
);
self.count = [0, 0];
self.since = Some(now);
}
}
}
struct Media {
diag: Diag,
clock: SinkClock,
video: VideoState,
audio: Option<AudioState>,
data_sock: TcpStream,
threads: Vec<JoinHandle<()>>,
}
pub struct MirrorSink<S: ControlStream> {
name: String,
caps: Capabilities,
session: Session<S>,
shared: Arc<Shared>,
media: Option<Media>,
clock: Option<SessionClock>,
feedback_timeout: Duration,
stopped: bool,
}
impl<S: ControlStream> MirrorSink<S> {
pub fn new(name: String, session: Session<S>, opts: &MirrorOptions) -> MirrorSink<S> {
let c = session.canvas;
let fps = c.max_fps.unwrap_or(60).clamp(1, 60);
let audio_formats = if opts.audio && session.audio.ports.is_some() {
match session.audio.codec {
AudioCodecId::Alac => vec![AudioFormat {
codec: AudioCodec::Alac,
sample_rate: SAMPLE_RATE,
channels: 2,
}],
AudioCodecId::AacEld => vec![AudioFormat {
codec: AudioCodec::AacEld,
sample_rate: SAMPLE_RATE,
channels: 2,
}],
}
} else {
Vec::new()
};
let caps = Capabilities {
max_width: c.width,
max_height: c.height,
max_fps: Ratio::integer(fps),
video_codecs: vec![VideoCodec::H264],
audio_formats,
audio_family: AudioFamily::AirPlay,
max_bitrate_kbps: Some(MAX_BITRATE_KBPS),
min_latency_ms: None,
preferred_latency_ms: Some(session.leads.video_ms),
display_aspect: crate::types::aspect_of(c.width, c.height)
.or(Some(crate::types::DEFAULT_DISPLAY_ASPECT)),
};
info!(
"airplay: {name}: session ready ({}, {}x{}@{fps}, audio {:?})",
match session.timeline {
Timeline::Ptp(_) => "PTP",
Timeline::Ntp => "NTP",
},
c.width,
c.height,
caps.audio_formats.first().map(|f| f.codec)
);
MirrorSink {
name,
caps,
session,
shared: Arc::new(Shared {
queue: Mutex::new(Queue::default()),
cond: Condvar::new(),
finished: AtomicBool::new(false),
failed: Mutex::new(None),
stopping: AtomicBool::new(false),
first_frame_sent: AtomicBool::new(false),
need_key: AtomicBool::new(false),
last_answer: Mutex::new(Instant::now()),
}),
feedback_timeout: opts.feedback_timeout,
media: None,
clock: None,
stopped: false,
}
}
pub fn session(&self) -> &Session<S> {
&self.session
}
fn audio_state(&self, audio: Option<&AudioInfo>) -> Result<Option<AudioState>> {
let (Some(info), Some(ports)) = (audio, self.session.audio.ports) else {
return Ok(None);
};
if info.codec != AudioCodec::PcmS16le || info.sample_rate != SAMPLE_RATE {
return Err(Error::unsupported(format!(
"airplay: audio must be 44.1 kHz s16le PCM (got {:?} at {} Hz)",
info.codec, info.sample_rate
)));
}
if self.session.audio.codec != AudioCodecId::Alac {
return Err(Error::unsupported(
"airplay: AAC-ELD audio is not implemented",
));
}
let ip = self.session.peer.ip();
let cipher = match (&self.session.audio.key, &self.session.fairplay) {
(Some(k), _) => AudioCipher::chacha(k),
(None, Some(fp)) => AudioCipher::aes_cbc(&fp.master, &fp.eiv)?,
(None, None) => AudioCipher::Clear,
};
let features = self.session.info.features;
let redundancy = if policy::has(features, bit::RFC2198) {
Redundancy::Rfc2198
} else {
Redundancy::Resend
};
let socks = &self.session.audio.sockets;
let clone = |s: &UdpSocket| {
s.try_clone()
.map_err(|e| Error::io("airplay: clone UDP", e))
};
let data = clone(&socks.data)?;
data.connect(SocketAddr::new(ip, ports.rtp))
.map_err(|e| Error::io("airplay: audio connect", e))?;
Ok(Some(AudioState {
channels: info.channels,
packetizer: Arc::new(Mutex::new(Packetizer::new(cipher, redundancy))),
data,
control: clone(&socks.control)?,
rtcp: SocketAddr::new(ip, ports.rtcp),
lead: Duration::from_millis(self.session.leads.audio_ms as u64),
lead_samples: self.session.leads.audio_samples(),
started: false,
stale: 0,
offset: 0,
last_pts: None,
last_capture: None,
last_sync: None,
first_sync: true,
window: (Instant::now(), 0),
frames: 0,
}))
}
fn spawn(
threads: &mut Vec<JoinHandle<()>>,
name: &str,
f: impl FnOnce() + Send + 'static,
) -> Result<()> {
threads.push(
std::thread::Builder::new()
.name(name.into())
.spawn(f)
.map_err(|e| Error::io(format!("airplay: spawn {name}"), e))?,
);
Ok(())
}
fn start_inner(&mut self, video: &VideoInfo, audio: Option<&AudioInfo>) -> Result<()> {
let vstate = VideoState::new(video, self.session.leads.video_ms)?;
let astate = self.audio_state(audio)?;
let data = self.session.start_video()?;
let cipher = if self.session.hap {
VideoCipher::chacha(&keys::video_key(
&self.session.secret.0,
self.session.video_id,
)?)
} else {
let shk = match (&self.session.fairplay, self.session.video_shk) {
(Some(fp), _) => fp.master,
(None, Some(shk)) => {
warn!("airplay: legacy profile without FairPlay (untested on any receiver)");
shk
}
(None, None) => return Err(Error::protocol("airplay: no video key")),
};
let (k, iv) = keys::legacy_video_key_iv(&shk, self.session.video_id);
VideoCipher::aes_ctr(&k, &iv)?
};
let mut threads = Vec::new();
let clone = |s: &TcpStream| {
s.try_clone()
.map_err(|e| Error::io("airplay: clone socket", e))
};
self.shared.answered();
{
let shared = self.shared.clone();
let sock = clone(&data)?;
let timeline = self.session.timeline.clone();
Self::spawn(&mut threads, "airplay-video", move || {
writer_loop(&shared, sock, cipher, timeline)
})?;
}
{
let shared = self.shared.clone();
let mut sock = clone(&data)?;
Self::spawn(&mut threads, "airplay-data", move || {
let mut buf = [0u8; 1024];
let error = loop {
match sock.read(&mut buf) {
Ok(0) => break None,
Err(e) if e.kind() == std::io::ErrorKind::ConnectionReset => break None,
Ok(n) => trace!("airplay: {n} bytes on the video data connection"),
Err(e)
if matches!(
e.kind(),
std::io::ErrorKind::WouldBlock
| std::io::ErrorKind::TimedOut
| std::io::ErrorKind::Interrupted
) => {}
Err(e) => break Some(e),
}
};
if shared.stopping.load(Ordering::Acquire) {
return;
}
match error {
None => {
info!("airplay: receiver closed the video connection");
shared.finished.store(true, Ordering::Release);
}
Some(e) => shared.fail(Error::io("airplay: video data connection", e)),
}
})?;
}
{
let shared = self.shared.clone();
let control = self.session.control.clone();
let timeline = self.session.timeline.clone();
Self::spawn(&mut threads, "airplay-feedback", move || {
feedback_loop(&shared, &control, &timeline)
})?;
}
if let Some(a) = &astate {
let shared = self.shared.clone();
let sock = a
.control
.try_clone()
.map_err(|e| Error::io("airplay: clone UDP", e))?;
let pk = a.packetizer.clone();
let ip = self.session.peer.ip();
Self::spawn(&mut threads, "airplay-rtcp", move || {
rtcp_loop(&shared, &sock, &pk, ip)
})?;
}
debug!(
"airplay: {}: streaming {}x{} video{}",
self.name,
vstate.width,
vstate.height,
if astate.is_some() {
" and ALAC audio"
} else {
""
}
);
self.media = Some(Media {
diag: Diag::default(),
clock: self
.clock
.clone()
.map_or_else(|| SinkClock::private(PRIVATE_CLOCK), SinkClock::shared),
video: vstate,
audio: astate,
data_sock: data,
threads,
});
Ok(())
}
fn queue_video(shared: &Shared, items: Vec<Item>, keyframe: bool) -> SinkStatus {
let mut q = shared.queue();
let bytes: usize = items.iter().map(Item::len).sum();
if q.closed {
return SinkStatus::Dropped;
}
if q.items.len() + items.len() > MAX_QUEUED || q.bytes + bytes > MAX_QUEUED_BYTES {
if !shared.need_key.swap(true, Ordering::AcqRel) {
debug!("airplay: video queue full; skipping to the next keyframe");
}
return SinkStatus::Dropped;
}
if keyframe {
shared.need_key.store(false, Ordering::Release);
}
q.bytes += bytes;
q.items.extend(items);
drop(q);
shared.cond.notify_all();
SinkStatus::Accepted
}
fn push_video(&mut self, frame: &EncodedFrame) -> Result<SinkStatus> {
let Some(m) = self.media.as_mut() else {
return Err(Error::protocol("airplay: push before start"));
};
let now = Instant::now();
let p = frame_payload(&frame.data, m.video.length_size)?;
if p.idr {
if let Some(sps) = p.sps.as_ref().filter(|s| **s != m.video.sps) {
debug!("airplay: SPS changed");
m.video.set_sps(sps.clone());
m.video.need_codec = true;
}
if let Some(pps) = p.pps.as_ref().filter(|s| **s != m.video.pps) {
debug!("airplay: PPS changed");
m.video.pps = pps.clone();
m.video.need_codec = true;
}
} else if m.video.need_codec || self.shared.need_key.load(Ordering::Acquire) {
return Ok(SinkStatus::Dropped);
}
if p.data.is_empty() {
return Ok(SinkStatus::Dropped);
}
let capture = capture_instant(&m.clock, frame.pts, VIDEO_CLOCK_RATE, now);
m.diag.note(
0,
ticks_to_duration(frame.pts, VIDEO_CLOCK_RATE),
now,
capture + Duration::from_millis(self.session.leads.video_ms as u64),
);
let ts = m
.video
.timestamp(self.session.timeline.at(capture).wrapping_add(m.video.lead));
let mut items = Vec::with_capacity(2);
if p.idr && m.video.need_codec {
let rec = avcc_record(&m.video.sps, &m.video.pps)?;
let mut pkt = codec_header(rec.len(), ts, m.video.width, m.video.height)?.to_vec();
pkt.extend_from_slice(&rec);
items.push(Item::Codec(pkt));
}
items.push(Item::Frame {
payload: p.data,
ts,
idr: p.idr,
});
let status = Self::queue_video(&self.shared, items, p.idr);
if status == SinkStatus::Accepted && p.idr {
m.video.need_codec = false;
if self
.session
.signals
.keyframe_requested
.swap(false, Ordering::AcqRel)
{
debug!("airplay: keyframe request served");
}
}
Ok(status)
}
fn push_audio(&mut self, frame: &EncodedFrame) -> Result<SinkStatus> {
let Some(m) = self.media.as_mut() else {
return Err(Error::protocol("airplay: push before start"));
};
let Some(a) = m.audio.as_mut() else {
return Ok(SinkStatus::Dropped);
};
if !self.shared.first_frame_sent.load(Ordering::Acquire) {
return Ok(SinkStatus::Dropped);
}
let now = Instant::now();
let r = a.push(frame, &m.clock, &self.session.timeline);
if let Some(capture) = m.clock.instant_for(frame.pts, SAMPLE_RATE) {
m.diag.note(
1,
ticks_to_duration(frame.pts, SAMPLE_RATE),
now,
capture + a.lead,
);
}
r
}
}
fn feedback_loop<S: ControlStream>(
shared: &Shared,
control: &Mutex<crate::airplay::session::Control<S>>,
timeline: &Timeline,
) {
let mut next = Instant::now();
loop {
{
let mut q = shared.queue();
loop {
if shared.stopping.load(Ordering::Acquire) || q.closed {
return;
}
let now = Instant::now();
if now >= next {
break;
}
q = shared
.cond
.wait_timeout(q, next - now)
.map(|(g, _)| g)
.unwrap_or_else(|e| e.into_inner().0);
}
}
next += FEEDBACK_INTERVAL;
let mut c = lock_control(control);
match c.request("POST", "/feedback", &[], None, DEFAULT_TIMEOUT) {
Ok(r) => {
let t1 = Instant::now();
drop(c);
shared.answered();
if !r.is_success() {
debug!("airplay: /feedback answered {}", r.status);
}
if let (Timeline::Ptp(clock), Some(r1)) =
(timeline, anchor_from_headers(&r.headers))
{
clock.reanchor(t1, r1);
}
}
Err(e) if c.is_broken() => {
drop(c);
shared.fail(e);
return;
}
Err(e) => warn!("airplay: /feedback: {e}"),
}
}
}
fn rtcp_loop(shared: &Shared, sock: &UdpSocket, pk: &Mutex<Packetizer>, peer: IpAddr) {
let _ = sock.set_read_timeout(Some(Duration::from_millis(100)));
let mut buf = [0u8; 2048];
while !shared.stopping.load(Ordering::Acquire) {
let (n, from) = match sock.recv_from(&mut buf) {
Ok(v) => v,
Err(_) => continue,
};
if from.ip() != peer {
continue;
}
let replies = lock_pk(pk).retransmit(&buf[..n]);
if replies.is_empty() {
trace!("airplay: {n} bytes on the audio control socket");
continue;
}
debug!("airplay: retransmitting {} audio packets", replies.len());
for r in replies {
let _ = sock.send_to(&r, from);
}
}
}
impl<S: ControlStream> Sink for MirrorSink<S> {
fn name(&self) -> &str {
&self.name
}
fn capabilities(&self) -> &Capabilities {
&self.caps
}
fn set_clock(&mut self, clock: SessionClock) {
self.clock = Some(clock);
}
fn start(&mut self, video: &VideoInfo, audio: Option<&AudioInfo>) -> Result<()> {
if self.media.is_some() {
return Err(Error::protocol("airplay: sink already started"));
}
self.start_inner(video, audio)
}
fn push(&mut self, frame: &EncodedFrame) -> Result<SinkStatus> {
if self.shared.finished.load(Ordering::Acquire) {
return Ok(SinkStatus::Finished);
}
if let Some(e) = self.shared.take_failure() {
return Err(e);
}
if self.media.is_some() {
let silent = self.shared.silent_for();
if silent >= self.feedback_timeout {
return Err(Error::timeout(format!(
"airplay: no answer to /feedback for {:.0} s",
silent.as_secs_f64()
)));
}
}
match frame.track {
TrackKind::Video => self.push_video(frame),
TrackKind::Audio(AudioFamily::AirPlay) => self.push_audio(frame),
TrackKind::Audio(_) => Ok(SinkStatus::Dropped),
}
}
fn wants_keyframe(&self) -> bool {
self.media.is_none()
|| self.shared.need_key.load(Ordering::Acquire)
|| self
.session
.signals
.keyframe_requested
.load(Ordering::Acquire)
}
fn stop(&mut self) -> Result<()> {
if self.stopped {
return Ok(());
}
self.stopped = true;
{
let mut q = self.shared.queue();
q.closed = true;
q.drain_until = Some(Instant::now() + STOP_DRAIN);
}
self.shared.cond.notify_all();
let mut threads = Vec::new();
if let Some(m) = self.media.as_mut() {
if let Some(w) = (!m.threads.is_empty()).then(|| m.threads.remove(0)) {
let _ = w.join();
}
threads = std::mem::take(&mut m.threads);
}
self.shared.stopping.store(true, Ordering::Release);
self.shared.cond.notify_all();
let r = self.session.teardown(STOP_TEARDOWN_TIMEOUT);
if let Some(m) = self.media.take() {
let _ = m.data_sock.shutdown(std::net::Shutdown::Both);
if let Some(a) = &m.audio {
debug!("airplay: sent {} audio frames", a.frames);
}
}
let deadline = Instant::now() + STOP_JOIN;
for t in threads {
crate::util::thread::join_until(t, deadline);
}
debug!("airplay: {}: stopped", self.name);
r
}
}
impl<S: ControlStream> Drop for MirrorSink<S> {
fn drop(&mut self) {
let _ = self.stop();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::airplay::fake_mirror::{Behaviour, FakeMirror, CLOCK_ID};
use crate::airplay::policy::Leads;
use crate::codec::bplist::Plist;
use crate::net::rtsp::RtspClient;
use crate::util::vectors;
fn connect(fake: &FakeMirror, opts: &MirrorOptions) -> MirrorSink<TcpStream> {
try_connect(fake, opts).unwrap()
}
fn try_connect(fake: &FakeMirror, opts: &MirrorOptions) -> Result<MirrorSink<TcpStream>> {
connect_with("fake".into(), opts, || {
let tcp = TcpStream::connect(fake.addr).unwrap();
Ok((RtspClient::new(tcp), fake.addr, fake.secret.clone(), true))
})
}
fn avcc() -> (Vec<u8>, Vec<u8>, Vec<u8>) {
let b = vectors::load("airplay-mirror/video.txt")
.into_iter()
.find(|b| b.name() == "avcC record for codec packet")
.unwrap();
let (sps, pps) = (b.hex("sps"), b.hex("pps"));
let mut rec = vec![1, sps[1], sps[2], sps[3], 0xff, 0xe1];
rec.extend_from_slice(&(sps.len() as u16).to_be_bytes());
rec.extend_from_slice(&sps);
rec.push(1);
rec.extend_from_slice(&(pps.len() as u16).to_be_bytes());
rec.extend_from_slice(&pps);
(rec, sps, pps)
}
fn nal(bytes: &[u8]) -> Vec<u8> {
[&(bytes.len() as u32).to_be_bytes()[..], bytes].concat()
}
fn video_info() -> VideoInfo {
VideoInfo {
codec: VideoCodec::H264,
width: 1920,
height: 1080,
fps: Ratio::integer(30),
avcc: avcc().0,
}
}
fn audio_info() -> AudioInfo {
AudioInfo {
codec: AudioCodec::PcmS16le,
sample_rate: 44_100,
channels: 2,
frame_samples: 352,
config: Vec::new(),
}
}
fn video(i: u64, sps: &[u8], pps: &[u8]) -> EncodedFrame {
let idr = i % 15 == 0;
let data = if idr {
[
nal(&[0x09, 0xf0]),
nal(sps),
nal(pps),
nal(&[0x65, 0x88, i as u8]),
]
.concat()
} else {
[nal(&[0x09, 0xf0]), nal(&[0x41, 0x9a, i as u8])].concat()
};
EncodedFrame {
track: TrackKind::Video,
pts: i * 3000,
keyframe: idr,
data: data.into(),
}
}
fn pcm(i: u64) -> Vec<u8> {
(0..352 * 2)
.flat_map(|s| ((s as i16).wrapping_mul(i as i16 + 1)).to_le_bytes())
.collect()
}
fn audio(i: u64) -> EncodedFrame {
EncodedFrame {
track: TrackKind::Audio(AudioFamily::AirPlay),
pts: i * 352,
keyframe: true,
data: pcm(i).into(),
}
}
fn wait_for(what: &str, mut f: impl FnMut() -> bool) {
let until = Instant::now() + Duration::from_secs(5);
while !f() {
assert!(Instant::now() < until, "timed out waiting for {what}");
std::thread::sleep(Duration::from_millis(10));
}
}
fn stream(sink: &mut MirrorSink<TcpStream>, frames: u64) -> Vec<SinkStatus> {
stream_with_stall(sink, frames, None).statuses
}
struct Streamed {
statuses: Vec<SinkStatus>,
late: Duration,
origins_ms: Vec<f64>,
}
const FRAME: Duration = Duration::from_micros(33_333);
fn stream_with_stall(
sink: &mut MirrorSink<TcpStream>,
frames: u64,
stall: Option<(u64, Duration)>,
) -> Streamed {
let (_, sps, pps) = avcc();
let t0 = Instant::now();
const PROBE: u64 = 3600 * VIDEO_CLOCK_RATE as u64;
let origin_ms = |sink: &MirrorSink<TcpStream>| {
let at = sink
.media
.as_ref()?
.clock
.instant_for(PROBE, VIDEO_CLOCK_RATE)?;
let at = at.checked_sub(ticks_to_duration(PROBE, VIDEO_CLOCK_RATE))?;
Some(match at.checked_duration_since(t0) {
Some(d) => d.as_secs_f64() * 1000.0,
None => -(t0 - at).as_secs_f64() * 1000.0,
})
};
let mut s = Streamed {
statuses: Vec::new(),
late: Duration::ZERO,
origins_ms: Vec::new(),
};
let mut a = 0u64;
for i in 0..frames {
let mut due = t0 + FRAME * i as u32;
if let Some((at, d)) = stall {
if i >= at {
due += d;
}
}
if let Some(d) = due.checked_duration_since(Instant::now()) {
std::thread::sleep(d);
}
s.late = s.late.max(Instant::now().saturating_duration_since(due));
s.statuses.push(sink.push(&video(i, &sps, &pps)).unwrap());
while a * 352 * 90_000 / 44_100 <= i * 3000 {
s.late = s.late.max(Instant::now().saturating_duration_since(due));
s.statuses.push(sink.push(&audio(a)).unwrap());
s.origins_ms.push(origin_ms(sink).unwrap_or(f64::NAN));
a += 1;
}
}
s
}
#[test]
fn streams_to_fake_receiver() {
let fake = FakeMirror::start(Behaviour::default());
let opts = MirrorOptions::default();
let mut sink = connect(&fake, &opts);
let caps = sink.capabilities().clone();
assert_eq!((caps.max_width, caps.max_height), (1280, 720));
assert_eq!(caps.audio_formats.len(), 1);
assert_eq!(caps.audio_family, AudioFamily::AirPlay);
sink.start(&video_info(), Some(&audio_info())).unwrap();
let statuses = stream(&mut sink, 40);
assert!(statuses.iter().all(|s| *s != SinkStatus::Finished));
wait_for("audio and video", || {
let r = fake.rec();
r.video.iter().filter(|p| p.kind == 0).count() == 40 && !r.retransmits.is_empty()
});
sink.stop().unwrap();
sink.stop().unwrap();
let r = fake.rec();
assert_eq!(
r.requests,
[
"GET /info",
&format!("SETUP rtsp://{}/{}", fake.addr, sink.session.audio_id),
"GET /info",
&format!("RECORD rtsp://{}/{}", fake.addr, sink.session.audio_id),
&format!("SETUP rtsp://{}/{}", fake.addr, sink.session.audio_id),
&format!("SETUP rtsp://{}/{}", fake.addr, sink.session.video_id),
"POST /feedback",
]
.iter()
.map(|s| s.to_string())
.chain(r.requests[7..].iter().cloned())
.collect::<Vec<_>>()
);
assert_eq!(
r.requests.last().unwrap(),
&format!("TEARDOWN rtsp://{}/{}", fake.addr, sink.session.audio_id)
);
assert!(r.teardown);
assert_eq!(r.event_replies, 1);
assert!(r.setup_bodies[0].get("timingPeerInfo").is_some());
let (_, sps, pps) = avcc();
let v = &r.video;
assert_eq!(v[0].kind, 1);
assert_eq!(v[0].payload, avcc_record(&sps, &pps).unwrap());
assert_eq!((v[1].kind, v[1].idr, v[1].ts), (0, true, v[0].ts));
assert_eq!(v[1].payload, nal(&[0x65, 0x88, 0]));
assert_eq!(v[1].timeline, CLOCK_ID);
let frames: Vec<&crate::airplay::fake_mirror::VideoPacket> =
v.iter().filter(|p| p.kind == 0).collect();
assert!(frames.windows(2).all(|w| w[1].ts > w[0].ts));
assert_eq!(frames[1].payload, nal(&[0x41, 0x9a, 1]));
assert!(!frames[1].idr && frames[15].idr);
assert_eq!(v.iter().filter(|p| p.kind == 1).count(), 1);
assert!(v.iter().any(|p| p.kind == 2), "heartbeat");
let dt = frames[30].ts - frames[0].ts;
let secs = dt as f64 / 4_294_967_296.0;
assert!((0.9..1.2).contains(&secs), "{secs}");
assert!(frames[0].ts >> 32 >= 1_201_707);
let a = &r.audio;
assert!(a.len() > 20, "{}", a.len());
assert_eq!((a[0].0, a[0].1), (1, 352));
assert_eq!(a[1].1 - a[0].1, 352);
assert_eq!(a[0].2.len(), 1416);
assert_eq!(&r.sync[0][..4], &[0x90, 0xd7, 0, 4]);
let play = u32::from_be_bytes(r.sync[0][4..8].try_into().unwrap());
assert_eq!(play, 352u32.wrapping_sub(Leads::new(None).audio_samples()));
assert_eq!(&r.sync[0][20..28], &CLOCK_ID.to_be_bytes());
assert!(r.sync.len() >= 2 && r.sync[1][0] == 0x80);
assert_eq!(r.retransmits.len(), 2);
for (i, p) in r.retransmits.iter().enumerate() {
assert_eq!(&p[..4], &[0x80, 0xd6, 0, 9]);
assert_eq!(p[5], 96);
assert_eq!(u16::from_be_bytes([p[6], p[7]]), i as u16 + 1);
}
}
#[test]
fn audio_payload_is_verbatim_alac() {
let fake = FakeMirror::start(Behaviour {
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), Some(&audio_info())).unwrap();
let late = stream_with_stall(&mut sink, 10, None).late;
wait_for("audio", || fake.rec().audio.len() >= 5);
sink.stop().unwrap();
let r = fake.rec();
let first = (0..20u64)
.find(|&src| alac_verbatim(&pcm(src), 2).unwrap() == r.audio[0].2)
.expect("ALAC payload of a pushed frame");
assert_eq!(r.audio[0].1, 352);
for (k, (seq, ts, payload)) in r.audio.iter().take(5).enumerate() {
assert_eq!(*seq as usize, k + 1);
assert_eq!(*payload, alac_verbatim(&pcm(first + k as u64), 2).unwrap());
if k > 0 {
let step = ts.wrapping_sub(r.audio[k - 1].1);
if late < MAX_LATENESS / 2 {
assert_eq!(step, 352, "{late:?}");
} else {
assert!((352..1 << 20).contains(&step), "{step} {late:?}");
}
}
}
}
#[test]
fn receiver_closing_data_finishes() {
let fake = FakeMirror::start(Behaviour {
close_after_packets: Some(3),
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), None).unwrap();
let (_, sps, pps) = avcc();
let mut end = None;
for i in 0..200 {
match sink.push(&video(i, &sps, &pps)) {
Ok(SinkStatus::Finished) => {
end = Some(SinkStatus::Finished);
break;
}
Err(e) => panic!("the receiver ending mirroring is no failure: {e}"),
_ => std::thread::sleep(Duration::from_millis(20)),
}
}
assert_eq!(end, Some(SinkStatus::Finished));
sink.stop().unwrap();
}
fn push_until_end(sink: &mut MirrorSink<TcpStream>) -> Result<SinkStatus> {
let (_, sps, pps) = avcc();
let until = Instant::now() + Duration::from_secs(15);
for i in 0.. {
assert!(Instant::now() < until, "the sink never noticed");
match sink.push(&video(i, &sps, &pps)) {
Ok(SinkStatus::Accepted | SinkStatus::Dropped) => {}
other => return other,
}
std::thread::sleep(Duration::from_millis(20));
}
unreachable!()
}
#[test]
fn vanished_receiver_fails_sink() {
let fake = FakeMirror::start(Behaviour {
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), None).unwrap();
stream(&mut sink, 5);
fake.vanish();
let e = push_until_end(&mut sink).unwrap_err();
assert_ne!(e.kind(), crate::error::ErrorKind::Unsupported, "{e}");
let t = Instant::now();
let _ = sink.stop();
assert!(t.elapsed() < Duration::from_secs(6), "{:?}", t.elapsed());
let mut again = connect(&fake, &MirrorOptions::default());
again.start(&video_info(), None).unwrap();
stream(&mut again, 5);
wait_for("second session", || {
fake.rec()
.video
.iter()
.any(|p| p.session == 1 && p.kind == 0)
});
again.stop().unwrap();
}
#[test]
fn unanswered_feedback_fails_sink() {
let fake = FakeMirror::start(Behaviour {
hang_feedback: true,
nack_after: None,
..Behaviour::default()
});
let opts = MirrorOptions {
feedback_timeout: Duration::from_millis(400),
..MirrorOptions::default()
};
let mut sink = connect(&fake, &opts);
sink.start(&video_info(), None).unwrap();
let t0 = Instant::now();
let e = push_until_end(&mut sink).unwrap_err();
assert_eq!(e.kind(), crate::error::ErrorKind::Timeout, "{e}");
assert!(t0.elapsed() >= Duration::from_millis(400));
let _ = sink.stop();
}
#[test]
fn receiver_keyframe_request() {
let fake = FakeMirror::start(Behaviour {
force_keyframe: true,
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), None).unwrap();
let (_, sps, pps) = avcc();
assert!(sink.push(&video(0, &sps, &pps)).unwrap() == SinkStatus::Accepted);
wait_for("forceKeyFrame", || sink.wants_keyframe());
sink.push(&video(1, &sps, &pps)).unwrap();
assert!(sink.wants_keyframe());
assert_eq!(
sink.push(&video(15, &sps, &pps)).unwrap(),
SinkStatus::Accepted
);
assert!(!sink.wants_keyframe());
sink.stop().unwrap();
}
#[test]
fn ptp_without_anchor_falls_back_to_ntp() {
let fake = FakeMirror::start(Behaviour {
no_timing_headers: true,
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
assert!(matches!(sink.session.timeline, Timeline::Ntp));
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 3);
sink.stop().unwrap();
let r = fake.rec();
let protocols: Vec<&str> = r
.setup_bodies
.iter()
.filter_map(|b| b.get("timingProtocol").and_then(Plist::as_str))
.collect();
assert_eq!(protocols, ["PTP", "NTP"]);
let first_teardown = r
.requests
.iter()
.position(|q| q.starts_with("TEARDOWN"))
.unwrap();
let second_info = r
.requests
.iter()
.skip(1)
.position(|q| q == "GET /info")
.unwrap()
+ 1;
assert!(first_teardown < second_info, "{:?}", r.requests);
assert!(r.video.iter().any(|p| p.kind == 0));
}
#[test]
fn stalled_receiver_fails_the_sink() {
let fake = FakeMirror::start(Behaviour {
stall_data: true,
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), None).unwrap();
let (_, sps, pps) = avcc();
let big = |i: u64| {
let mut f = video(i, &sps, &pps);
let mut d = f.data.to_vec();
d.extend(nal(&vec![0x41; 256 * 1024]));
f.data = d.into();
f
};
let t0 = Instant::now();
let mut dropped = 0;
let err = loop {
assert!(t0.elapsed() < Duration::from_secs(20), "never failed");
match sink.push(&big(dropped % 15)) {
Ok(SinkStatus::Dropped) => dropped += 1,
Ok(_) => {}
Err(e) => break e,
}
std::thread::sleep(Duration::from_millis(2));
};
assert!(dropped > 0, "queue never filled");
assert!(sink.wants_keyframe());
assert_eq!(err.kind(), crate::error::ErrorKind::Timeout, "{err}");
let t = Instant::now();
sink.stop().unwrap();
assert!(t.elapsed() < Duration::from_secs(3));
}
#[test]
fn legacy_profile_media() {
let master = [0x25; 16];
let eiv = [0xf0; 16];
let fake = FakeMirror::start(Behaviour {
legacy: Some((master, eiv)),
nack_after: None,
..Behaviour::default()
});
let tcp = TcpStream::connect(fake.addr).unwrap();
let opts = MirrorOptions::default();
let mut session = Session::establish(
RtspClient::new(tcp),
fake.addr,
fake.secret.clone(),
false,
&opts,
)
.map_err(SetupError::into_error)
.unwrap();
assert!(matches!(session.timeline, Timeline::Ntp));
assert!(session.audio.key.is_none());
session.fairplay = Some(crate::airplay::session::FairPlayKeys {
master,
eiv,
ekey: [0; 72],
});
let mut sink = MirrorSink::new("legacy".into(), session, &opts);
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 20);
wait_for("media", || {
let r = fake.rec();
r.video.iter().filter(|p| p.kind == 0).count() == 20 && r.audio.len() > 5
});
sink.stop().unwrap();
let r = fake.rec();
assert_eq!(r.event_replies, 1, "plaintext event channel");
let frames: Vec<_> = r.video.iter().filter(|p| p.kind == 0).collect();
assert_eq!(frames[0].payload, nal(&[0x65, 0x88, 0]));
assert_eq!(frames[19].payload, nal(&[0x41, 0x9a, 19]));
assert_eq!(frames[0].timeline, 0);
let first = (0..20u64)
.find(|&src| alac_verbatim(&pcm(src), 2).unwrap() == r.audio[0].2)
.expect("CBC audio decrypts to a pushed frame");
assert_eq!(r.audio[1].2, alac_verbatim(&pcm(first + 1), 2).unwrap());
assert!(r.setup_bodies[0].get("ekey").is_none());
assert_eq!(
r.setup_bodies[0]
.get("timingProtocol")
.and_then(Plist::as_str),
Some("NTP")
);
}
#[test]
fn legacy_without_fairplay() {
let fake = FakeMirror::start(Behaviour {
legacy: Some(([0; 16], [0; 16])),
legacy_no_fairplay: true,
nack_after: None,
..Behaviour::default()
});
let tcp = TcpStream::connect(fake.addr).unwrap();
let opts = MirrorOptions::default();
let session = Session::establish(
RtspClient::new(tcp),
fake.addr,
fake.secret.clone(),
false,
&opts,
)
.map_err(SetupError::into_error)
.unwrap();
assert!(session.fairplay.is_none());
let mut sink = MirrorSink::new("legacy".into(), session, &opts);
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 10);
wait_for("media", || {
let r = fake.rec();
r.video.iter().filter(|p| p.kind == 0).count() == 10 && r.audio.len() > 3
});
sink.stop().unwrap();
let r = fake.rec();
assert!(r.setup_bodies.iter().all(|b| b.get("ekey").is_none()));
let frames: Vec<_> = r.video.iter().filter(|p| p.kind == 0).collect();
assert_eq!(frames[0].payload, nal(&[0x65, 0x88, 0]));
assert_eq!(frames[9].payload, nal(&[0x41, 0x9a, 9]));
assert!((0..20u64).any(|src| alac_verbatim(&pcm(src), 2).unwrap() == r.audio[0].2));
}
#[test]
fn hap_receiver_offering_fairplay_streams_either_way() {
let fake = FakeMirror::start(Behaviour {
fairplay_bit: true,
nack_after: None,
..Behaviour::default()
});
let opts = MirrorOptions::default();
let mut sink = connect(&fake, &opts);
assert!(sink.session.fairplay.is_none());
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 5);
wait_for("video", || {
fake.rec().video.iter().filter(|p| p.kind == 0).count() == 5
});
sink.stop().unwrap();
let tried = fake.rec().requests.iter().any(|r| r.contains("/fp-setup"));
assert_eq!(tried, crate::airplay::session::FAIRPLAY_BUILT);
}
#[test]
fn legacy_receiver_needs_fairplay() {
let fake = FakeMirror::start(Behaviour {
legacy: Some(([0; 16], [0; 16])),
legacy_no_fairplay: true,
fairplay_bit: true,
nack_after: None,
..Behaviour::default()
});
let tcp = TcpStream::connect(fake.addr).unwrap();
let r = Session::establish(
RtspClient::new(tcp),
fake.addr,
fake.secret.clone(),
false,
&MirrorOptions::default(),
)
.map_err(SetupError::into_error);
if crate::airplay::session::FAIRPLAY_BUILT {
assert!(r.unwrap().fairplay.is_none());
} else {
let e = r.err().unwrap();
assert_eq!(e.code(), Some("fairplay-required"), "{e}");
assert!(e.to_string().contains("`fairplay` feature"), "{e}");
assert!(fake.rec().setup_bodies.is_empty());
}
}
#[test]
fn refusal_without_fairplay_names_it() {
let fake = FakeMirror::start(Behaviour {
fairplay_bit: true,
refuse_session_setup: Some(403),
nack_after: None,
..Behaviour::default()
});
let tcp = TcpStream::connect(fake.addr).unwrap();
let e = Session::establish(
RtspClient::new(tcp),
fake.addr,
fake.secret.clone(),
true,
&MirrorOptions::default(),
)
.map_err(SetupError::into_error)
.err()
.unwrap();
assert_eq!(
e.code() == Some("fairplay-required"),
!crate::airplay::session::FAIRPLAY_BUILT,
"{e}"
);
}
#[test]
fn source_stall_keeps_audio_mapping() {
let fake = FakeMirror::start(Behaviour {
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), Some(&audio_info())).unwrap();
let stall = Duration::from_millis(400);
let st = stream_with_stall(&mut sink, 84, Some((36, stall)));
wait_for("sync after the stall", || fake.rec().sync.len() >= 3);
sink.stop().unwrap();
let r = fake.rec();
let ms = |d: Duration| d.as_secs_f64() * 1000.0;
let samples_ms = |n: u32| n as i32 as f64 * 1000.0 / 44_100.0;
let index: std::collections::HashMap<Vec<u8>, usize> = (0..st.origins_ms.len())
.map(|a| (alac_verbatim(&pcm(a as u64), 2).unwrap(), a))
.collect();
let got: Vec<(usize, u32)> = r
.audio
.iter()
.map(|(_, rtp, payload)| (index[payload], *rtp))
.collect();
let (a0, rtp0) = got[0];
let origin0 = st.origins_ms[a0];
let mut gaps_ms = Vec::new();
let mut last_gap = 0.0;
for &(a, rtp) in &got {
let gap = samples_ms(rtp.wrapping_sub(rtp0).wrapping_sub((a - a0) as u32 * 352));
let moved = st.origins_ms[a] - origin0;
assert!(
(gap - moved).abs() < 0.1,
"audio frame {a}: RTP gap {gap} ms, clock moved {moved} ms since frame {a0}"
);
if gap - last_gap > 0.1 {
gaps_ms.push(gap - last_gap);
}
last_gap = gap;
}
let (late_ms, stall_ms) = (ms(st.late + FRAME) + 5.0, ms(stall));
let end = *st.origins_ms.last().unwrap();
let what = format!(
"gaps {gaps_ms:?} ms, {:?} late, origins {origin0} -> {end} ms",
st.late
);
assert!((-1.0..=late_ms).contains(&origin0), "{what}");
assert!(
(stall_ms - 1.0..=stall_ms + late_ms).contains(&end),
"{what}"
);
let total: f64 = gaps_ms.iter().sum();
assert!(
(stall_ms - origin0 - 1.0..=stall_ms + late_ms).contains(&total),
"{what}"
);
assert!(
gaps_ms.iter().all(|&g| g >= ms(MAX_LATENESS) - 1.0),
"{what}"
);
if late_ms < ms(MAX_LATENESS) {
assert_eq!(gaps_ms.len(), 1, "{what}");
}
let points: Vec<(u32, u64)> = r
.sync
.iter()
.map(|p| {
(
u32::from_be_bytes(p[4..8].try_into().unwrap()),
u64::from_be_bytes(p[8..16].try_into().unwrap()),
)
})
.collect();
let (r0, t0) = points[0];
for &(rtp, t) in &points[1..] {
let by_rtp = rtp.wrapping_sub(r0) as f64 / 44_100.0;
let by_time = (t - t0) as f64 / 1e9;
assert!(
(by_rtp - by_time).abs() < 0.003,
"sync mapping moved: {by_rtp} s of samples vs {by_time} s"
);
}
assert!(r.sync[1..].iter().all(|p| p[0] == 0x80));
}
#[test]
fn fake_receiver_ignores_stray_udp() {
let fake = FakeMirror::start(Behaviour {
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), Some(&audio_info())).unwrap();
let a = sink.media.as_ref().unwrap().audio.as_ref().unwrap();
let (data, rtcp) = (a.data.peer_addr().unwrap(), a.rtcp);
let stray = UdpSocket::bind("127.0.0.1:0").unwrap();
let mut junk = vec![0x80u8, 0x60, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0];
junk.extend_from_slice(&[7; 40]);
let send = || {
stray.send_to(&junk, data).unwrap();
stray.send_to(&junk, rtcp).unwrap();
};
send();
stream(&mut sink, 10);
send();
stream(&mut sink, 10);
wait_for("audio, sync and four strays", || {
let r = fake.rec();
!r.audio.is_empty() && !r.sync.is_empty() && r.strays == 4
});
sink.stop().unwrap();
let r = fake.rec();
assert_eq!(r.strays, 4);
assert!(r.sync.iter().all(|p| p[1] == 0xd7));
}
#[test]
fn stop_is_bounded_when_the_receiver_hangs() {
let fake = FakeMirror::start(Behaviour {
hang_feedback: true,
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 5);
wait_for("feedback", || {
fake.rec().requests.iter().any(|r| r == "POST /feedback")
});
let t = Instant::now();
let _ = sink.stop();
assert!(t.elapsed() < Duration::from_secs(6), "{:?}", t.elapsed());
}
#[test]
fn eof_after_teardown_is_a_clean_stop() {
let fake = FakeMirror::start(Behaviour {
teardown_eof: true,
nack_after: None,
..Behaviour::default()
});
let mut sink = connect(&fake, &MirrorOptions::default());
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 5);
sink.stop().unwrap();
assert!(fake.rec().teardown);
}
#[test]
fn media_first_ordering() {
let fake = FakeMirror::start(Behaviour {
refuse_session_setup: Some(455),
nack_after: None,
..Behaviour::default()
});
let opts = MirrorOptions::default();
let mut sink = connect(&fake, &opts);
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 5);
sink.stop().unwrap();
let r = fake.rec();
let audio_uri = format!("rtsp://{}/{}", fake.addr, sink.session.audio_id);
assert_eq!(
r.requests[..6],
[
"GET /info".to_string(),
format!("SETUP {audio_uri}"),
format!("SETUP {audio_uri}"),
"GET /info".into(),
format!("SETUP rtsp://{}/{}", fake.addr, sink.session.video_id),
format!("RECORD {audio_uri}"),
]
);
let mf = &r.setup_bodies[1];
assert!(mf.get("sessionUUID").is_some() && mf.get("streams").is_some());
assert!(mf.get("updateSessionRequest").is_none());
assert!(r.video.iter().any(|p| p.kind == 0));
}
#[test]
fn ntp_session() {
let fake = FakeMirror::start(Behaviour {
nack_after: None,
..Behaviour::default()
});
let opts = MirrorOptions {
ptp: false,
..MirrorOptions::default()
};
let mut sink = connect(&fake, &opts);
assert!(matches!(sink.session.timeline, Timeline::Ntp));
sink.start(&video_info(), Some(&audio_info())).unwrap();
stream(&mut sink, 5);
wait_for("sync", || !fake.rec().sync.is_empty());
sink.stop().unwrap();
let r = fake.rec();
assert_eq!(
r.setup_bodies[0]
.get("timingProtocol")
.and_then(Plist::as_str),
Some("NTP")
);
assert!(r.setup_bodies[0].get("timingPort").is_some());
assert_eq!(&r.sync[0][..2], &[0x90, 0xd4]);
assert_eq!(r.sync[0].len(), 20);
let f = r.video.iter().find(|p| p.kind == 0).unwrap();
assert_eq!(f.timeline, 0);
}
}