mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
fix(video): keep streaming after display wake failures (#95)
Fixes #94.
This commit is contained in:
4 files changed
+144
-4
No files matched your search
+19
-2
@@ -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);
|
||||
|
||||
@@ -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; }
|
||||
Reference in new issue
Block a user