fix(video): keep streaming after display wake failures (#95)

Fixes #94.
This commit is contained in:
阿夜 authored and GitHub committed 2026-10-22 21:24:51 -07:00
1 parent fa7606894f
commit 1009bdeaf2
4 files changed
+144 -4

No files matched your search

+19 -2
View File
@@ -1,3 +1,7 @@
#[cfg(test)]
#[path = "video_wake_tests.rs"]
mod wake_tests;
use std::collections::HashMap;
use std::ffi::OsString;
use std::path::PathBuf;
@@ -530,6 +534,8 @@ async fn read_encoder(
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
selection: crate::video_select::Selection,
) -> Result<(), String> {
#[cfg(test)]
if display == wake_tests::DISPLAY { return wake_tests::encode(latest, settings, sequence, budget).await; }
// The sequence is shared so a CPU fallback or settings restart continues it (skip statistics stay correct).
// `selection` is fixed for this desktop connection (taken where the codec is negotiated).
let encoder = selection.encoder;
@@ -954,6 +960,15 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
Ok(())
}
fn keep_stream_display_awake() {
#[cfg(test)]
let result = wake_tests::wake().unwrap_or_else(crate::capture::keep_display_awake);
#[cfg(not(test))]
let result = crate::capture::keep_display_awake();
// Waking the output is optional; a transient failure does not mean capture failed.
if result.is_err() { log::warn!("Display wake failed; continuing desktop stream and retrying next interval"); }
}
pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_track::VideoTrack>, mut size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
mut settings: tokio::sync::watch::Receiver<VideoSettings>, applied: Arc<tokio::sync::watch::Sender<VideoSettings>>, idr: Arc<AtomicBool>,
selection: crate::video_select::Selection) -> Result<(), String> {
@@ -966,7 +981,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
}
// Portal power/idle policy belongs to its CONTROL-scoped supervisor,
// including when video has no frames or the user locks manually.
if portal.is_none() { crate::capture::keep_display_awake()?; }
if portal.is_none() { keep_stream_display_awake(); }
let portal_stream = portal.is_some();
let (latest, mut receiver) = mpsc::channel(4);
let budget=Arc::new(Semaphore::new(4));
@@ -1080,8 +1095,10 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
previous = Some(frame.sequence);
max_send_ms=max_send_ms.max(send_started.elapsed().as_millis());
frames += 1;
#[cfg(test)]
if wake_tests::active() { stats = Instant::now() - Duration::from_secs(30); }
if stats.elapsed() >= Duration::from_secs(30) {
if !portal_stream { crate::capture::keep_display_awake()?; }
if !portal_stream { keep_stream_display_awake(); }
log::info!("Desktop latest-frame stats: sent={} skipped={} latest_seq={} window_s={} window_sent={} window_skipped={} max_slot_age_ms={} max_send_ms={}",
frames, skipped, frame.sequence, stats.elapsed().as_secs(), frames - window_frames, skipped - window_skipped, max_age_ms, max_send_ms);
(window_frames, window_skipped) = (frames, skipped);
+123
View File
@@ -0,0 +1,123 @@
//! Exercise the real video loop and RTP transport without cloud or desktop access.
//! Thread-local faults are confined to each test's current-thread Tokio runtime.
use super::*;
use std::cell::RefCell;
use webrtc::{api::{APIBuilder, media_engine::MediaEngine},
peer_connection::configuration::RTCConfiguration,
rtp_transceiver::rtp_codec::RTPCodecType};
pub(super) const DISPLAY: &str = "wayland:test-wake";
struct Faults { wake_calls: AtomicUsize, fail_wake: usize, fail_capture: bool, stop: AtomicBool }
thread_local! { static FAULTS: RefCell<Option<Arc<Faults>>> = const { RefCell::new(None) }; }
struct Reset;
impl Drop for Reset { fn drop(&mut self) { FAULTS.with(|value| *value.borrow_mut() = None); } }
pub(super) fn active() -> bool { FAULTS.with(|value| value.borrow().is_some()) }
pub(super) fn wake() -> Option<Result<(), String>> {
FAULTS.with(|value| value.borrow().as_ref().map(|faults| {
let call = faults.wake_calls.fetch_add(1, Ordering::SeqCst) + 1;
if call == faults.fail_wake { Err("Wayland output power control unavailable".into()) } else { Ok(()) }
}))
}
pub(super) async fn encode(latest: mpsc::Sender<Arc<CompleteFrame>>, settings: VideoSettings,
sequence: Arc<std::sync::atomic::AtomicU64>, budget: Arc<Semaphore>) -> Result<(), String> {
let faults = FAULTS.with(|value| value.borrow().clone()).expect("test faults installed");
loop {
tokio::time::sleep(Duration::from_millis(10)).await;
if faults.stop.load(Ordering::SeqCst) { return Ok(()); }
if faults.fail_capture && sequence.load(Ordering::Relaxed) >= 4 {
return Err("synthetic capture failed".into());
}
let permit = budget.clone().acquire_owned().await.map_err(|_| "test budget closed")?;
let frame = Arc::new(CompleteFrame {
source_generation: settings.source_generation, source_id: settings.source_id,
codec: settings.codec, sequence: sequence.fetch_add(1, Ordering::Relaxed) + 1,
completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2], _permit: Some(permit),
});
if latest.send(frame).await.is_err() { return Ok(()); }
}
}
async fn exercise(fail_wake: usize, fail_capture: bool) {
tokio::time::timeout(Duration::from_secs(15), async {
let faults = Arc::new(Faults { wake_calls: AtomicUsize::new(0), fail_wake, fail_capture, stop: AtomicBool::new(false) });
FAULTS.with(|value| *value.borrow_mut() = Some(faults.clone()));
let _reset = Reset;
let (host_setting, remote_setting, router) = crate::test_network::virtual_network().await;
let mut media = MediaEngine::default();
media.register_default_codecs().unwrap();
let host = Arc::new(APIBuilder::new().with_setting_engine(host_setting).with_media_engine(media)
.build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let mut media = MediaEngine::default();
media.register_default_codecs().unwrap();
let remote = APIBuilder::new().with_setting_engine(remote_setting).with_media_engine(media)
.build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
remote.add_transceiver_from_kind(RTPCodecType::Video, None).await.unwrap();
let _control = remote.create_data_channel("CONTROL_DATA_CHANNEL", None).await.unwrap();
let track = Arc::new(crate::video_track::VideoTrack::new());
host.add_track(track.clone()).await.unwrap();
let (packets, mut received) = mpsc::unbounded_channel();
remote.on_track(Box::new(move |track, _, _| {
let packets = packets.clone();
Box::pin(async move {
tokio::spawn(async move {
while let Ok((packet, _)) = track.read_rtp().await {
if packets.send(packet).is_err() { break; }
}
});
})
}));
let mut gathered = remote.gathering_complete_promise().await;
remote.set_local_description(remote.create_offer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
host.set_remote_description(remote.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.gathering_complete_promise().await;
host.set_local_description(host.create_answer(None).await.unwrap()).await.unwrap();
gathered.recv().await;
remote.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
let settings = VideoSettings { source_id: 0, source_generation: 0, ..Default::default() };
let (settings_tx, settings_rx) = tokio::sync::watch::channel(settings);
let selection = crate::video_select::resolve_pair(Some("cpu"), None, Some("h264"), None, false);
let mut task = tokio::spawn(stream_desktop(host.clone(), track.clone(), (640, 480),
DISPLAY.into(), None, settings_rx, Arc::new(settings_tx), Arc::new(AtomicBool::new(false)), selection));
let result = if fail_capture {
Some((&mut task).await.unwrap())
} else {
let mut previous: Option<u16> = None;
for _ in 0..6 {
tokio::select! {
result = &mut task => panic!("video stopped after a recoverable wake failure: {result:?}"),
packet = received.recv() => {
let packet = packet.expect("RTP receiver closed");
if let Some(sequence) = previous {
assert_eq!(packet.header.sequence_number, sequence.wrapping_add(1));
}
previous = Some(packet.header.sequence_number);
}
}
}
assert!(faults.wake_calls.load(Ordering::SeqCst) > fail_wake, "wake was not retried");
None
};
assert!(track.revision() >= 4, "video must continue across wake failure");
let result = match result {
Some(result) => result,
None => {
faults.stop.store(true, Ordering::SeqCst);
task.await.unwrap()
},
};
host.close().await.unwrap();
remote.close().await.unwrap();
router.lock().await.stop().await.unwrap();
assert_eq!(result, if fail_capture { Err("synthetic capture failed".into()) } else { Ok(()) });
}).await.expect("video wake regression timed out");
}
#[tokio::test]
async fn startup_wake_failure_does_not_stop_video() { exercise(1, false).await; }
#[tokio::test]
async fn periodic_wake_failure_does_not_stop_video() { exercise(2, false).await; }
#[tokio::test]
async fn capture_failure_still_stops_video_after_wake_failure() { exercise(2, true).await; }