mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Video: probe the auto encoder in the background (NVENC then CPU) (#93)
Refs #85 (step 2).
This commit is contained in:
1 parent
1009bdeaf2
commit
9d3b3da3f5
9 files changed
+752
-58
No files matched your search
+21
-1
@@ -131,7 +131,7 @@ pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, na
|
||||
/// hosts default to H.264. UU_VIDEO_CODEC=h264 / h265 overrides.
|
||||
#[cfg(test)]
|
||||
fn test_selection() -> crate::video_select::Selection {
|
||||
crate::video_select::resolve_pair(Some("auto"), None, Some("auto"), None, false)
|
||||
crate::video_select::resolve_pair(Some("auto"), None, Some("auto"), None, false, None)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -601,6 +601,26 @@ mod codec_tests {
|
||||
apply_rpc(&request, &tx, (1920, 1080), true, true, false, Some("h265")).unwrap();
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H265);
|
||||
}
|
||||
#[test]
|
||||
fn true_color_keeps_codec_and_vaapi_reports_420() {
|
||||
// Field 7 = 3 (真彩). full_chroma false is the VAAPI 4:2:0 drop; true encodes 4:4:4.
|
||||
let request = decode_wire(&[18, 2, 56, 3]).unwrap();
|
||||
let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() });
|
||||
apply_rpc(&request, &tx, (1920, 1080), true, true, true, None).unwrap();
|
||||
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265));
|
||||
// NVENC session (full chroma) that already chose H.265 stays H.265 when 真彩 is requested.
|
||||
let nvenc = crate::video_select::resolve_pair(None, None, None, None, true, None);
|
||||
assert_eq!(nvenc.encoder, crate::video::Encoder::Nvenc);
|
||||
let (tx, rx) = watch::channel(VideoSettings { codec: preferred_codec_for(true, true, nvenc), ..VideoSettings::default() });
|
||||
assert_eq!(rx.borrow().codec, VideoCodec::H265);
|
||||
handle_rpc_for(&request, &tx, (1920, 1080), true, true, nvenc).unwrap();
|
||||
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_444, VideoCodec::H265));
|
||||
let (tx, rx) = watch::channel(VideoSettings { codec: VideoCodec::H265, ..Default::default() });
|
||||
apply_rpc(&request, &tx, (1920, 1080), true, true, false, None).unwrap();
|
||||
assert_eq!((rx.borrow().chroma, rx.borrow().codec), (CHROMA_420, VideoCodec::H265));
|
||||
assert_eq!(number(&decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap(), 3), Some(CHROMA_420));
|
||||
assert!(decode_wire(&sync_payload(&rx.borrow(), (1920, 1080))).unwrap().iter().all(|f| f.number != 13));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -16,6 +16,13 @@ fn env_state(name: &str) -> String {
|
||||
|
||||
fn line(key: &str, value: impl std::fmt::Display) { println!("{key:<22} {}", redact(&value.to_string())); }
|
||||
|
||||
fn format_probe(probe: &crate::video_select::ProbeReport) -> String {
|
||||
let body = probe.order.iter().zip(probe.outcomes.iter())
|
||||
.map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label()))
|
||||
.collect::<Vec<_>>().join(" ");
|
||||
if probe.expires_at.is_some() { format!("{body} (failure result, retried after 10 min)") } else { body }
|
||||
}
|
||||
|
||||
fn glibc() -> String {
|
||||
#[cfg(all(target_os = "linux", target_env = "gnu"))]
|
||||
{
|
||||
@@ -95,6 +102,13 @@ pub async fn run() -> Result<(), String> {
|
||||
let selection = crate::video_select::selection();
|
||||
let env_enc = std::env::var("UU_VIDEO_ENCODER").unwrap_or_else(|_| "unset".into());
|
||||
let codec = match selection.codec_pref { crate::video_select::CodecPref::Auto => "auto", crate::video_select::CodecPref::H264 => "h264", crate::video_select::CodecPref::H265 => "h265" };
|
||||
let probe_text = if selection.encoder_source == crate::video_select::Source::Auto {
|
||||
format_probe(&crate::video::run_auto_probe().await)
|
||||
} else {
|
||||
crate::video_select::cached_probe().as_ref().map(format_probe).unwrap_or_else(|| "not yet run".to_owned())
|
||||
};
|
||||
let selection = if selection.encoder_source == crate::video_select::Source::Auto { crate::video_select::selection() } else { selection };
|
||||
line("encoder probe", probe_text);
|
||||
line("encoder", format!("{:?} (source={}; UU_VIDEO_ENCODER={env_enc})", selection.encoder, crate::video_select::encoder_source_label(selection.encoder_source)));
|
||||
line("codec", format!("{codec} (source={})", crate::video_select::source_label(selection.codec_source)));
|
||||
// Both codecs offered: hardware prefers H.265, CPU stays H.264 unless the preference forces one.
|
||||
|
||||
@@ -521,6 +521,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
virtual_audio::init();
|
||||
let _audio_cleanup=virtual_audio::Cleanup;
|
||||
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
|
||||
video::warm_auto_probe();
|
||||
|
||||
if !desktop_backend::headless() && desktop_backend::detect()? == desktop_backend::DesktopBackend::X11 && desktop_backend::wayland_session_running() {
|
||||
// X11 capture inside a Wayland session reads XWayland's root window: all black, no error (#61).
|
||||
@@ -850,6 +851,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
|
||||
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac);
|
||||
if desktop { input.set_mac_controller(controller_mac); }
|
||||
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
|
||||
// An expired NVENC failure is re-probed in the background. This offer keeps the cached encoder.
|
||||
if desktop { video::warm_auto_probe(); }
|
||||
// Replace only this ICE id or a previous desktop, never tool peers.
|
||||
for id in superseded_peer_ids(&sessions, &ice, desktop) {
|
||||
if let Some(old) = sessions.remove(&id) { let _ = old.pc.close().await; }
|
||||
|
||||
+179
-23
@@ -442,6 +442,109 @@ fn hevc_cell(cache: &HevcCache, spec: &FfmpegSpec, encoder: Encoder) -> Arc<toki
|
||||
/// passes the session's encoder so capability matches that snapshot. set-encoder
|
||||
/// changes the snapshot for the next session, so a process-wide bool would keep advertising
|
||||
/// the first session's result.
|
||||
const AUTO_PROBE_BUDGET: Duration = Duration::from_secs(3);
|
||||
|
||||
/// One synthetic H.264 IDR. Failure reasons stay enum values: stderr and device paths are not logged.
|
||||
pub(crate) async fn probe_encoder_idr(encoder: Encoder) -> crate::video_select::ProbeOutcome {
|
||||
use crate::video_select::{ProbeFail, ProbeOutcome};
|
||||
let settings = VideoSettings { codec: VideoCodec::H264, ..Default::default() };
|
||||
let mut command = ffmpeg_command();
|
||||
command.args(["-hide_banner", "-loglevel", "error", "-nostdin"]);
|
||||
if encoder == Encoder::Vaapi { command.args(["-vaapi_device", &vaapi_device()]); }
|
||||
command.args(["-f", "lavfi", "-i", "color=c=black:s=256x256:r=1", "-frames:v", "1", "-an"]);
|
||||
if encoder == Encoder::Vaapi { command.args(["-vf", &vaapi_filter(None)]); }
|
||||
command.args(encoder_options(&settings, encoder, "30", None));
|
||||
command.args(["-f", "h264", "pipe:1"]).kill_on_drop(true).stderr(std::process::Stdio::null());
|
||||
let process = match tokio::time::timeout(AUTO_PROBE_BUDGET, command.output()).await {
|
||||
Ok(Ok(output)) if output.status.success() && is_independent_frame_for(&output.stdout, VideoCodec::H264) => ProbeOutcome::Ok,
|
||||
Ok(Ok(output)) if output.status.success() => ProbeOutcome::Fail(ProbeFail::NoIdr),
|
||||
Ok(Ok(_)) => ProbeOutcome::Fail(ProbeFail::Exit),
|
||||
Ok(Err(_)) => ProbeOutcome::Fail(ProbeFail::Spawn),
|
||||
Err(_) => ProbeOutcome::Fail(ProbeFail::Timeout),
|
||||
};
|
||||
// The native engine opens against a real X display, so a synthetic lavfi frame cannot
|
||||
// exercise it. When this build would try that engine first, a process-only failure must
|
||||
// not drop the candidate (NativeUnprobed → legacy auto for it).
|
||||
crate::video_select::outcome_for_candidate(process, native_engine_would_run(encoder))
|
||||
}
|
||||
|
||||
/// True when `read_encoder_with` would open the in-process engine for this candidate
|
||||
/// on the selected desktop backend (X11 only; not Wayland, portal, KMS, or headless).
|
||||
fn native_engine_would_run(encoder: Encoder) -> bool {
|
||||
native_engine_eligible(encoder, native_display_kind())
|
||||
}
|
||||
|
||||
fn native_display_kind() -> NativeDisplayKind {
|
||||
if crate::desktop_backend::headless() { return NativeDisplayKind::None; }
|
||||
match crate::desktop_backend::detect() {
|
||||
Ok(crate::desktop_backend::DesktopBackend::Wayland) => NativeDisplayKind::Wayland,
|
||||
Ok(crate::desktop_backend::DesktopBackend::Kms) => NativeDisplayKind::Kms,
|
||||
Ok(crate::desktop_backend::DesktopBackend::Portal) => NativeDisplayKind::Portal,
|
||||
_ => NativeDisplayKind::X11,
|
||||
}
|
||||
}
|
||||
|
||||
fn auto_probe_flight() -> &'static tokio::sync::Mutex<()> {
|
||||
static FLIGHT: std::sync::OnceLock<tokio::sync::Mutex<()>> = std::sync::OnceLock::new();
|
||||
FLIGHT.get_or_init(|| tokio::sync::Mutex::new(()))
|
||||
}
|
||||
|
||||
/// Start the auto probe when auto is selected and the cache is empty or stale
|
||||
/// (TTL, or NVIDIA presence changed since the report). Returns immediately.
|
||||
/// One probe runs at a time; an in-flight probe is left alone.
|
||||
/// Explicit encoder (setting or `UU_VIDEO_ENCODER`) does not spawn a probe.
|
||||
pub fn warm_auto_probe() {
|
||||
if !crate::video_select::should_warm_auto_probe(crate::video_select::selection().encoder_source) { return; }
|
||||
if !crate::video_select::probe_needs_run(std::time::Instant::now(), nvidia_present()) { return; }
|
||||
tokio::spawn(async { let _ = run_auto_probe().await; });
|
||||
}
|
||||
|
||||
/// Diagnostics that encode must see the same auto choice as a warmed-up host.
|
||||
/// An explicit encoder (setting or env) skips the probe.
|
||||
pub async fn ensure_auto_probed() {
|
||||
if crate::video_select::selection().encoder_source == crate::video_select::Source::Auto {
|
||||
let _ = run_auto_probe().await;
|
||||
}
|
||||
}
|
||||
|
||||
/// Run the probe to completion (doctor, or the background warm-up).
|
||||
/// A success or a CPU-only skip stays cached. A hardware failure expires after
|
||||
/// `PROBE_FAILURE_TTL`; the next `warm_auto_probe` starts one background retry.
|
||||
pub async fn run_auto_probe() -> crate::video_select::ProbeReport {
|
||||
let now = std::time::Instant::now();
|
||||
let nvidia = nvidia_present();
|
||||
if let Some(cached) = crate::video_select::cached_probe() {
|
||||
if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; }
|
||||
}
|
||||
let _flight = auto_probe_flight().lock().await;
|
||||
let now = std::time::Instant::now();
|
||||
let nvidia = nvidia_present();
|
||||
if let Some(cached) = crate::video_select::cached_probe() {
|
||||
if !crate::video_select::probe_stale(&cached, now, nvidia) { return cached; }
|
||||
}
|
||||
let reason = crate::video_select::reprobe_reason(crate::video_select::cached_probe().as_ref(), nvidia);
|
||||
let nvidia = nvidia_present();
|
||||
let order = crate::video_select::auto_order(nvidia);
|
||||
// One candidate (CPU, no NVIDIA) has nothing to choose; skip the synthetic IDR.
|
||||
let mut outcomes = Vec::with_capacity(order.len());
|
||||
if order.len() == 1 {
|
||||
outcomes.push(crate::video_select::ProbeOutcome::NotProbed);
|
||||
} else {
|
||||
for encoder in &order { outcomes.push(probe_encoder_idr(*encoder).await); }
|
||||
}
|
||||
let probed = crate::video_select::choose_from_probe(&order, &outcomes);
|
||||
let chosen = crate::video_select::chosen_after_native(nvidia, &order, &outcomes, probed);
|
||||
let report = crate::video_select::ProbeReport::fresh(order, outcomes, chosen, now, nvidia);
|
||||
let parts: Vec<String> = report.order.iter().zip(report.outcomes.iter()).map(|(e, o)| format!("{}={}", format!("{e:?}").to_ascii_lowercase(), o.label())).collect();
|
||||
if let Some(reason) = reason {
|
||||
log::info!("Encoder probe: {reason} {}", parts.join(" "));
|
||||
} else {
|
||||
log::info!("Encoder probe: {}", parts.join(" "));
|
||||
}
|
||||
crate::video_select::store_probe(report.clone());
|
||||
report
|
||||
}
|
||||
|
||||
pub async fn hevc_available(requested: Encoder) -> bool {
|
||||
let spec = ffmpeg_spec();
|
||||
let cell = hevc_cell(hevc_cache(), &spec, requested);
|
||||
@@ -531,7 +634,7 @@ impl Drop for StopOnDrop { fn drop(&mut self) { self.0.store(true, std::sync::at
|
||||
async fn read_encoder(
|
||||
size: (u32, u32), display: String, portal:Option<Arc<crate::portal::PortalSession>>,
|
||||
latest: mpsc::Sender<Arc<CompleteFrame>>,
|
||||
settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
mut settings: VideoSettings, sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
|
||||
selection: crate::video_select::Selection,
|
||||
) -> Result<(), String> {
|
||||
#[cfg(test)]
|
||||
@@ -539,6 +642,10 @@ async fn read_encoder(
|
||||
// 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;
|
||||
if settings.chroma == crate::capture_setting::CHROMA_444 && !full_chroma_for(encoder) {
|
||||
settings.chroma = crate::capture_setting::CHROMA_420;
|
||||
log::info!("Chroma 4:4:4 requested; encoder={} source={} encodes 4:2:0", format!("{encoder:?}").to_ascii_lowercase(), crate::video_select::encoder_source_label(selection.encoder_source));
|
||||
}
|
||||
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await; }
|
||||
#[cfg_attr(not(feature = "inproc-av"), allow(unused_mut))]
|
||||
let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await;
|
||||
@@ -567,10 +674,29 @@ fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u3
|
||||
crate::capture::x11_size().filter(|current| *current != size)
|
||||
}
|
||||
|
||||
/// Same predicate `native_inproc` uses: X11 only, and the in-process engine is selected.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) enum NativeDisplayKind { X11, Wayland, Portal, Kms, None }
|
||||
|
||||
pub(crate) fn native_engine_eligible(encoder: Encoder, kind: NativeDisplayKind) -> bool {
|
||||
#[cfg(feature = "inproc-av")]
|
||||
{ kind == NativeDisplayKind::X11 && crate::inproc_encoder::selected(encoder) }
|
||||
#[cfg(not(feature = "inproc-av"))]
|
||||
{ let _ = (encoder, kind); false }
|
||||
}
|
||||
|
||||
/// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session).
|
||||
#[cfg(feature = "inproc-av")]
|
||||
fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool {
|
||||
!display.starts_with("wayland:") && !display.starts_with("kms:") && !portal && crate::inproc_encoder::selected(encoder)
|
||||
native_engine_eligible(encoder, display_kind(display, portal))
|
||||
}
|
||||
|
||||
#[cfg(feature = "inproc-av")]
|
||||
fn display_kind(display: &str, portal: bool) -> NativeDisplayKind {
|
||||
if portal { NativeDisplayKind::Portal }
|
||||
else if display.starts_with("wayland:") { NativeDisplayKind::Wayland }
|
||||
else if display.starts_with("kms:") { NativeDisplayKind::Kms }
|
||||
else { NativeDisplayKind::X11 }
|
||||
}
|
||||
|
||||
/// Capture and encode inside this process; each packet is one access unit.
|
||||
@@ -828,7 +954,9 @@ pub(crate) fn transport_closed(pc: &RTCPeerConnection) -> bool {
|
||||
|| pc.sctp().state() == webrtc::sctp_transport::sctp_transport_state::RTCSctpTransportState::Closed
|
||||
}
|
||||
|
||||
fn probe_settings() -> Result<VideoSettings,String> {
|
||||
/// Encoder and settings for `desktop-video-probe` / `UU_PROBE_INPUT`.
|
||||
/// `UU_PROBE_CHROMA=444` is the viewer's 真彩 request, applied when the selected encoder can do 4:4:4.
|
||||
pub(crate) fn probe_plan() -> Result<(crate::video_select::Selection, VideoSettings), String> {
|
||||
let fps=crate::wayland::capture_fps(std::env::var("UU_PROBE_FPS").ok().as_deref())?;
|
||||
// UU_PROBE_QUALITY selects a viewer preset (1 fast 1M, 2 general 2M, 3 HD 8M, 4 bluray 20M,
|
||||
// 5 auto); bitrate presets exercise the capped/ABR encoder path instead of CRF.
|
||||
@@ -836,19 +964,15 @@ fn probe_settings() -> Result<VideoSettings,String> {
|
||||
None=>crate::capture_setting::QUALITY_AUTO,
|
||||
Some(v)=>v.parse::<u64>().ok().filter(|q|(1..=5).contains(q)).ok_or("UU_PROBE_QUALITY must be 1-5")?,
|
||||
};
|
||||
let mut settings=VideoSettings {fps,quality,codec:probe_codec(),..VideoSettings::default()};
|
||||
// UU_PROBE_CHROMA=444 requests 真彩 like the viewer does (only where full_chroma_available()).
|
||||
if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") && full_chroma_for(crate::video_select::selection().encoder) { settings.chroma=crate::capture_setting::CHROMA_444; }
|
||||
Ok(settings)
|
||||
}
|
||||
|
||||
/// The probe follows `UU_VIDEO_CODEC` so the HEVC path can be measured at all (H.264 otherwise),
|
||||
/// and its first access unit is then checked against that codec instead of always H.264.
|
||||
fn probe_codec() -> VideoCodec {
|
||||
match crate::video_select::codec_force(crate::video_select::selection().codec_pref) {
|
||||
let mut settings=VideoSettings {fps,quality,..VideoSettings::default()};
|
||||
let selection = crate::video_select::selection();
|
||||
let chroma = if std::env::var("UU_PROBE_CHROMA").as_deref()==Ok("444") { crate::capture_setting::CHROMA_444 } else { crate::capture_setting::CHROMA_420 };
|
||||
settings.codec = match crate::video_select::codec_force(selection.codec_pref) {
|
||||
Some("h265") => VideoCodec::H265,
|
||||
_ => VideoCodec::H264,
|
||||
}
|
||||
};
|
||||
if chroma == crate::capture_setting::CHROMA_444 && full_chroma_for(selection.encoder) { settings.chroma = chroma; }
|
||||
Ok((selection, settings))
|
||||
}
|
||||
|
||||
fn probe_input_command(spec:&FfmpegSpec,input:&std::ffi::OsStr,loop_input:bool,settings:&VideoSettings,
|
||||
@@ -883,13 +1007,14 @@ async fn probe_input_size(spec:&FfmpegSpec,input:&std::ffi::OsStr)->Result<(u32,
|
||||
|
||||
/// Fixed input bypasses desktop initialization and always uses the FFmpeg process encoder.
|
||||
pub async fn probe_input(input:OsString,path:Option<String>)->Result<(),String> {
|
||||
ensure_auto_probed().await;
|
||||
use std::io::Write;
|
||||
let settings=probe_settings()?;
|
||||
let (selection, settings)=probe_plan()?;
|
||||
let wanted:u64=std::env::var("UU_PROBE_FRAMES").ok().and_then(|v|v.parse().ok()).unwrap_or(5);
|
||||
if wanted==0 { return Err("Fixed-input UU_PROBE_FRAMES must be positive".into()); }
|
||||
let spec=ffmpeg_spec();
|
||||
let size=probe_input_size(&spec,&input).await?;
|
||||
let encoder = crate::video_select::selection().encoder;
|
||||
let encoder = selection.encoder;
|
||||
let (maxrate,_)=rate_args(&settings,encoder);
|
||||
let output=settings.output.unwrap_or(size);
|
||||
println!("Fixed input probe: source={}x{} output={}x{} fps={} cq={} maxrate={} encoder={}",
|
||||
@@ -933,6 +1058,7 @@ pub async fn probe_input(input:OsString,path:Option<String>)->Result<(),String>
|
||||
|
||||
/// Exercise the real capture/encoder chain without UU auth or a network peer.
|
||||
pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal::PortalSession>>,path:Option<String>)->Result<(),String> {
|
||||
ensure_auto_probed().await;
|
||||
use std::io::Write;
|
||||
let mut file=match path {
|
||||
Some(path)=>Some(std::fs::OpenOptions::new().write(true).create_new(true).open(path).map_err(|e|format!("Video probe file: {e}"))?),
|
||||
@@ -940,8 +1066,7 @@ pub async fn probe(size:(u32,u32),display:String,portal:Option<Arc<crate::portal
|
||||
};
|
||||
let (tx,mut rx)=mpsc::channel(4);
|
||||
let sequence=Arc::new(std::sync::atomic::AtomicU64::new(0));
|
||||
let settings=probe_settings()?;
|
||||
let selection = crate::video_select::selection();
|
||||
let (selection, settings)=probe_plan()?;
|
||||
let _reader=EncoderTask(tokio::spawn(read_encoder(size,display,portal,tx,settings,sequence,Arc::new(AtomicBool::new(false)),Arc::new(Semaphore::new(4)),selection)));
|
||||
let mut count=0;
|
||||
let mut bytes=0;
|
||||
@@ -993,7 +1118,18 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
settings.borrow_and_update();
|
||||
}
|
||||
// Reader restarts reuse this snapshot, so set-encoder waits for the next desktop connection.
|
||||
let mut reader = EncoderTask(tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone(), selection)));
|
||||
let open = {
|
||||
let display = display.clone();
|
||||
let portal = portal.clone();
|
||||
let latest = latest.clone();
|
||||
let sequence = sequence.clone();
|
||||
let idr = idr.clone();
|
||||
let budget = budget.clone();
|
||||
move |size: (u32, u32), selection: crate::video_select::Selection, settings: VideoSettings| {
|
||||
read_encoder(size, display.clone(), portal.clone(), latest.clone(), settings, sequence.clone(), idr.clone(), budget.clone(), selection)
|
||||
}
|
||||
};
|
||||
let mut reader = EncoderTask(tokio::spawn(open(size, selection, current)));
|
||||
let mut previous = None;
|
||||
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
|
||||
let mut settings_open = true;
|
||||
@@ -1019,9 +1155,9 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
reader.0.abort();
|
||||
let _ = (&mut reader.0).await;
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone(), selection));
|
||||
reader.0 = tokio::spawn(open(size, selection, next));
|
||||
} else {
|
||||
reader.restart(read_encoder(size, display.clone(), portal.clone(), latest.clone(), next, sequence.clone(), idr.clone(), budget.clone(), selection)).await;
|
||||
reader.restart(open(size, selection, next)).await;
|
||||
}
|
||||
send_interrupted=false;
|
||||
}
|
||||
@@ -1032,7 +1168,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
log::info!("Desktop geometry changed during the stream ({}x{} -> {}x{}); restarting capture", size.0, size.1, resized.0, resized.1);
|
||||
size = resized;
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone(), selection));
|
||||
reader.0 = tokio::spawn(open(size, selection, current));
|
||||
continue;
|
||||
}
|
||||
if let (Err(error), VideoCodec::H265, true) = (&result, current.codec, track.supports(VideoCodec::H264)) {
|
||||
@@ -1040,7 +1176,7 @@ pub async fn stream_desktop(pc: Arc<RTCPeerConnection>, track: Arc<crate::video_
|
||||
applied.send_modify(|value| value.codec = VideoCodec::H264);
|
||||
current = *settings.borrow_and_update();
|
||||
while receiver.try_recv().is_ok() {}
|
||||
reader.0 = tokio::spawn(read_encoder(size, display.clone(), portal.clone(), latest.clone(), current, sequence.clone(), idr.clone(), budget.clone(), selection));
|
||||
reader.0 = tokio::spawn(open(size, selection, current));
|
||||
continue;
|
||||
}
|
||||
if result.is_err() && !crate::wayland::outputs().is_empty() && !crate::wayland::input_ready() {
|
||||
@@ -1255,6 +1391,26 @@ mod tests {
|
||||
assert!(!timing_args(FfmpegTimingMode::Modern, 60).contains(&"-r".to_owned()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_unprobed_only_when_x11_inproc_is_eligible() {
|
||||
use crate::video_select::{outcome_for_candidate, ProbeFail, ProbeOutcome};
|
||||
let exit = ProbeOutcome::Fail(ProbeFail::Exit);
|
||||
for kind in [NativeDisplayKind::Wayland, NativeDisplayKind::Portal, NativeDisplayKind::Kms, NativeDisplayKind::None] {
|
||||
assert!(!native_engine_eligible(Encoder::Nvenc, kind), "{kind:?}");
|
||||
assert_eq!(outcome_for_candidate(exit, native_engine_eligible(Encoder::Nvenc, kind)), exit);
|
||||
}
|
||||
assert!(!native_engine_eligible(Encoder::Cpu, NativeDisplayKind::X11));
|
||||
let x11 = native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11);
|
||||
let stored = outcome_for_candidate(exit, x11);
|
||||
if cfg!(feature = "inproc-av") && native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::X11) {
|
||||
assert!(x11);
|
||||
assert_eq!(stored, ProbeOutcome::NativeUnprobed);
|
||||
} else {
|
||||
assert!(!x11);
|
||||
assert_eq!(stored, exit);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timing_probe_failure_keeps_modern_args() {
|
||||
let modern = b" -fps_mode mode\n -enc_time_base ratio\n";
|
||||
|
||||
+504
-15
@@ -1,6 +1,8 @@
|
||||
//! Runtime encoder / codec preference. host_settings.json beats the environment,
|
||||
//! and "auto" or a missing field falls through. Illegal values are ignored.
|
||||
//! Auto keeps the v0.2.23 rule (NVENC when an NVIDIA driver is present, otherwise CPU).
|
||||
//! Auto follows `auto_order` (NVENC then CPU when NVIDIA is present, else CPU).
|
||||
//! A finished background probe can replace that choice; an unfinished probe keeps
|
||||
//! the legacy NVIDIA/CPU result so the first connection is not delayed.
|
||||
|
||||
use crate::video::Encoder;
|
||||
|
||||
@@ -65,22 +67,190 @@ fn file_fields() -> (Option<String>, Option<String>) {
|
||||
|
||||
/// Unset/auto tries NVENC only with an NVIDIA driver loaded: `ffmpeg -encoders` lists h264_nvenc
|
||||
/// on any machine, so without this every stream start first ran a doomed NVENC process (#10).
|
||||
fn legacy_auto(nvidia: bool) -> Encoder {
|
||||
pub fn legacy_auto(nvidia: bool) -> Encoder {
|
||||
if nvidia { Encoder::Nvenc } else { Encoder::Cpu }
|
||||
}
|
||||
|
||||
/// Auto candidate order. NVIDIA present: NVENC then CPU. No NVIDIA: CPU only.
|
||||
/// VAAPI is not an auto candidate until #33 (FFmpeg-process VAAPI ignores maxrate).
|
||||
/// Explicit vaapi (setting or `UU_VIDEO_ENCODER`) is unchanged.
|
||||
pub fn auto_order(nvidia: bool) -> Vec<Encoder> {
|
||||
if nvidia { vec![Encoder::Nvenc, Encoder::Cpu] } else { vec![Encoder::Cpu] }
|
||||
}
|
||||
|
||||
/// Why one candidate's synthetic IDR did not count. Logged as the variant name only.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum ProbeFail { Timeout, NoIdr, Spawn, Exit }
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum ProbeOutcome {
|
||||
Ok,
|
||||
Fail(ProbeFail),
|
||||
/// inproc-av only: the FFmpeg process probe failed, but this session would try the native
|
||||
/// engine first (`read_encoder_with`) on an X11 display (not Wayland, portal, or KMS).
|
||||
/// Opening that engine needs a display, so the candidate is not failed here; auto falls
|
||||
/// back to the pre-probe NVIDIA/CPU choice for it.
|
||||
NativeUnprobed,
|
||||
/// Single auto candidate (CPU, no NVIDIA): the synthetic IDR is skipped.
|
||||
NotProbed,
|
||||
}
|
||||
|
||||
impl ProbeOutcome {
|
||||
/// Counts as a successful probe for `choose_from_probe`.
|
||||
/// `NativeUnprobed` does not: that candidate was not shown to encode.
|
||||
pub fn ok(self) -> bool { matches!(self, Self::Ok) }
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Self::Ok => "ok",
|
||||
Self::Fail(ProbeFail::Timeout) => "timeout",
|
||||
Self::Fail(ProbeFail::NoIdr) => "no_idr",
|
||||
Self::Fail(ProbeFail::Spawn) => "spawn",
|
||||
Self::Fail(ProbeFail::Exit) => "exit",
|
||||
Self::NativeUnprobed => "native_unprobed",
|
||||
Self::NotProbed => "not probed (only candidate)",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// How a process-probe result becomes the stored outcome.
|
||||
/// `native_would_run` is true only on inproc-av when `inproc_encoder::selected` is true
|
||||
/// (hardware, not `UU_VIDEO_PIPELINE=process` / `UU_CAPTURE=grab` / a bundled FFmpeg).
|
||||
/// A process failure then becomes `NativeUnprobed` instead of disqualifying that candidate.
|
||||
/// Default builds pass `native_would_run = false`, so the process result is unchanged.
|
||||
pub fn outcome_for_candidate(process: ProbeOutcome, native_would_run: bool) -> ProbeOutcome {
|
||||
if process.ok() || !native_would_run { process } else { ProbeOutcome::NativeUnprobed }
|
||||
}
|
||||
|
||||
/// Encoder auto should use when a hardware candidate was left `NativeUnprobed`.
|
||||
/// That candidate is skipped by `choose_from_probe`; if it was the legacy pick (NVENC when
|
||||
/// NVIDIA is present), keep the legacy encoder. Otherwise use the probe choice.
|
||||
pub fn chosen_after_native(nvidia: bool, order: &[Encoder], outcomes: &[ProbeOutcome], probed: Encoder) -> Encoder {
|
||||
let legacy = legacy_auto(nvidia);
|
||||
let native_legacy = order.iter().zip(outcomes.iter()).any(|(e, o)| {
|
||||
*e == legacy && matches!(o, ProbeOutcome::NativeUnprobed)
|
||||
});
|
||||
if native_legacy { legacy } else { probed }
|
||||
}
|
||||
|
||||
/// How long a hardware-candidate failure stays cached. A boot-time NVENC miss
|
||||
/// (module not ready, GPU busy, consumer session limit) must not stick until exit.
|
||||
pub const PROBE_FAILURE_TTL: std::time::Duration = std::time::Duration::from_secs(600);
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct ProbeReport {
|
||||
pub order: Vec<Encoder>,
|
||||
pub outcomes: Vec<ProbeOutcome>,
|
||||
pub chosen: Encoder,
|
||||
/// `None` means the result does not expire (success, or CPU-only `NotProbed`).
|
||||
pub expires_at: Option<std::time::Instant>,
|
||||
/// `nvidia_present()` at the time the report was stored. A later desktop
|
||||
/// connection whose presence differs treats the report as stale.
|
||||
pub nvidia: bool,
|
||||
}
|
||||
|
||||
impl ProbeReport {
|
||||
pub fn fresh(order: Vec<Encoder>, outcomes: Vec<ProbeOutcome>, chosen: Encoder, now: std::time::Instant, nvidia: bool) -> Self {
|
||||
let expires_at = probe_failure_deadline(&order, &outcomes, chosen, now);
|
||||
Self { order, outcomes, chosen, expires_at, nvidia }
|
||||
}
|
||||
}
|
||||
|
||||
/// Expiry is only for the hardware candidate that caused the CPU fallback
|
||||
/// (NVENC `Fail` and `chosen == Cpu`). A `Fail` on CPU while NVENC is `Ok`
|
||||
/// does not expire, and doctor does not label that report a failure.
|
||||
/// `NotProbed` and `Ok` do not. `NativeUnprobed` keeps the legacy encoder
|
||||
/// and is not a failure cache.
|
||||
pub fn probe_failure_deadline(
|
||||
order: &[Encoder],
|
||||
outcomes: &[ProbeOutcome],
|
||||
chosen: Encoder,
|
||||
now: std::time::Instant,
|
||||
) -> Option<std::time::Instant> {
|
||||
let hardware_failed = order.iter().zip(outcomes).any(|(encoder, outcome)| {
|
||||
*encoder != Encoder::Cpu && matches!(outcome, ProbeOutcome::Fail(_))
|
||||
});
|
||||
(hardware_failed && chosen == Encoder::Cpu).then_some(now + PROBE_FAILURE_TTL)
|
||||
}
|
||||
|
||||
pub fn probe_expired(report: &ProbeReport, now: std::time::Instant) -> bool {
|
||||
report.expires_at.is_some_and(|at| now >= at)
|
||||
}
|
||||
|
||||
/// Time-to-live elapsed, or NVIDIA presence no longer matches the report.
|
||||
/// Presence is `nvidia_present()` (proc version or `/dev/nvidia0`).
|
||||
pub fn probe_stale(report: &ProbeReport, now: std::time::Instant, nvidia: bool) -> bool {
|
||||
probe_expired(report, now) || report.nvidia != nvidia
|
||||
}
|
||||
|
||||
/// Log suffix for a probe that replaces `previous`. `None` is a first probe.
|
||||
/// A failure deadline (`expires_at`) is "retry after failure". A presence
|
||||
/// mismatch without that deadline is "NVIDIA availability changed".
|
||||
pub fn reprobe_reason(previous: Option<&ProbeReport>, nvidia_now: bool) -> Option<&'static str> {
|
||||
let previous = previous?;
|
||||
if previous.expires_at.is_some() {
|
||||
Some("retry after failure")
|
||||
} else if previous.nvidia != nvidia_now {
|
||||
Some("NVIDIA availability changed")
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Empty cache, or the cached report is stale for `nvidia` at `now`.
|
||||
/// Callers still use the cached encoder until the replacement probe is stored.
|
||||
pub fn probe_needs_run(now: std::time::Instant, nvidia: bool) -> bool {
|
||||
match cached_probe() {
|
||||
None => true,
|
||||
Some(report) => probe_stale(&report, now, nvidia),
|
||||
}
|
||||
}
|
||||
|
||||
/// Background warm-up (startup and each new desktop connection) runs only for auto.
|
||||
/// Setting or `UU_VIDEO_ENCODER` (non-auto) matches v0.2.23: no GPU probe.
|
||||
pub fn should_warm_auto_probe(source: Source) -> bool {
|
||||
source == Source::Auto
|
||||
}
|
||||
|
||||
/// First candidate that produced an IDR, else CPU.
|
||||
pub fn choose_from_probe(order: &[Encoder], outcomes: &[ProbeOutcome]) -> Encoder {
|
||||
order.iter().zip(outcomes.iter()).find_map(|(e, o)| o.ok().then_some(*e)).unwrap_or(Encoder::Cpu)
|
||||
}
|
||||
|
||||
fn cache() -> &'static std::sync::Mutex<Option<ProbeReport>> {
|
||||
static CACHE: std::sync::OnceLock<std::sync::Mutex<Option<ProbeReport>>> = std::sync::OnceLock::new();
|
||||
CACHE.get_or_init(|| std::sync::Mutex::new(None))
|
||||
}
|
||||
|
||||
pub fn store_probe(report: ProbeReport) {
|
||||
if let Ok(mut slot) = cache().lock() { *slot = Some(report); }
|
||||
}
|
||||
|
||||
pub fn cached_probe() -> Option<ProbeReport> {
|
||||
cache().lock().ok().and_then(|g| g.clone())
|
||||
}
|
||||
|
||||
/// Tests that call `clear_probe` / `store_probe` share this lock. The probe
|
||||
/// cache is process-global and `cargo test` runs tests in parallel.
|
||||
#[cfg(test)]
|
||||
pub(crate) static PROBE_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
|
||||
|
||||
#[cfg(test)]
|
||||
pub fn clear_probe() {
|
||||
if let Ok(mut slot) = cache().lock() { *slot = None; }
|
||||
}
|
||||
|
||||
/// Setting (non-auto) beats the environment, which beats the NVIDIA/CPU default.
|
||||
pub fn selection() -> Selection {
|
||||
selection_with(cached_probe().as_ref())
|
||||
}
|
||||
|
||||
/// Same as `selection`, but auto uses `report` when it is already cached.
|
||||
/// `None` keeps the legacy NVIDIA/CPU result (the probe is still running or has not started).
|
||||
pub fn selection_with(report: Option<&ProbeReport>) -> Selection {
|
||||
let (file_enc, file_codec) = file_fields();
|
||||
let env_enc = std::env::var("UU_VIDEO_ENCODER").ok();
|
||||
let env_codec = std::env::var("UU_VIDEO_CODEC").ok();
|
||||
resolve_pair(
|
||||
file_enc.as_deref(),
|
||||
env_enc.as_deref(),
|
||||
file_codec.as_deref(),
|
||||
env_codec.as_deref(),
|
||||
crate::video::nvidia_present(),
|
||||
)
|
||||
resolve_pair(file_enc.as_deref(), env_enc.as_deref(), file_codec.as_deref(), env_codec.as_deref(), crate::video::nvidia_present(), report)
|
||||
}
|
||||
|
||||
pub fn resolve_pair(
|
||||
@@ -89,14 +259,15 @@ pub fn resolve_pair(
|
||||
codec_setting: Option<&str>,
|
||||
codec_env: Option<&str>,
|
||||
nvidia: bool,
|
||||
probed: Option<&ProbeReport>,
|
||||
) -> Selection {
|
||||
let (encoder, encoder_source) = match parse_encoder(enc_setting) {
|
||||
Some(Some(e)) => (e, Source::Setting),
|
||||
None => {
|
||||
log::warn!("Ignoring video_encoder value (not auto/cpu/vaapi/nvenc)");
|
||||
pick_encoder(enc_env, nvidia)
|
||||
pick_encoder(enc_env, nvidia, probed)
|
||||
}
|
||||
Some(None) => pick_encoder(enc_env, nvidia),
|
||||
Some(None) => pick_encoder(enc_env, nvidia, probed),
|
||||
};
|
||||
let (codec_pref, codec_source) = match parse_codec(codec_setting) {
|
||||
Some(Some(p)) => (p, Source::Setting),
|
||||
@@ -114,17 +285,21 @@ pub fn resolve_pair(
|
||||
}
|
||||
}
|
||||
|
||||
fn pick_encoder(env: Option<&str>, nvidia: bool) -> (Encoder, Source) {
|
||||
fn pick_encoder(env: Option<&str>, nvidia: bool, probed: Option<&ProbeReport>) -> (Encoder, Source) {
|
||||
match parse_encoder(env) {
|
||||
Some(Some(e)) => (e, Source::Env),
|
||||
None => {
|
||||
log::warn!("Ignoring UU_VIDEO_ENCODER value (not auto/cpu/vaapi/nvenc)");
|
||||
(legacy_auto(nvidia), Source::Auto)
|
||||
(auto_encoder(nvidia, probed), Source::Auto)
|
||||
}
|
||||
Some(None) => (legacy_auto(nvidia), Source::Auto),
|
||||
Some(None) => (auto_encoder(nvidia, probed), Source::Auto),
|
||||
}
|
||||
}
|
||||
|
||||
fn auto_encoder(nvidia: bool, probed: Option<&ProbeReport>) -> Encoder {
|
||||
probed.map(|p| p.chosen).unwrap_or_else(|| legacy_auto(nvidia))
|
||||
}
|
||||
|
||||
fn pick_codec(env: Option<&str>) -> (CodecPref, Source) {
|
||||
match parse_codec(env) {
|
||||
Some(Some(p)) => (p, Source::Env),
|
||||
@@ -176,7 +351,7 @@ mod tests {
|
||||
ce: Option<&str>,
|
||||
nvidia: bool,
|
||||
) -> Selection {
|
||||
resolve_pair(es, ee, cs, ce, nvidia)
|
||||
resolve_pair(es, ee, cs, ce, nvidia, None)
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -241,4 +416,318 @@ mod tests {
|
||||
CodecPref::H265
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn process_failure_keeps_native_candidate_unprobed() {
|
||||
let exit = ProbeOutcome::Fail(ProbeFail::Exit);
|
||||
assert_eq!(outcome_for_candidate(ProbeOutcome::Ok, true), ProbeOutcome::Ok);
|
||||
assert_eq!(outcome_for_candidate(exit, false), exit, "default build keeps the process result");
|
||||
assert_eq!(outcome_for_candidate(exit, true), ProbeOutcome::NativeUnprobed);
|
||||
assert!(!ProbeOutcome::NativeUnprobed.ok());
|
||||
assert_eq!(ProbeOutcome::NativeUnprobed.label(), "native_unprobed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_unprobed_hardware_uses_legacy_choice() {
|
||||
let order = auto_order(true);
|
||||
let outcomes = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok];
|
||||
let probed = choose_from_probe(&order, &outcomes);
|
||||
assert_eq!(probed, Encoder::Cpu);
|
||||
assert_eq!(chosen_after_native(true, &order, &outcomes, probed), Encoder::Nvenc);
|
||||
let cpu_only = auto_order(false);
|
||||
assert_eq!(chosen_after_native(false, &cpu_only, &[ProbeOutcome::Ok], Encoder::Cpu), Encoder::Cpu);
|
||||
let both_ok = [ProbeOutcome::Ok, ProbeOutcome::Ok];
|
||||
assert_eq!(chosen_after_native(true, &order, &both_ok, Encoder::Nvenc), Encoder::Nvenc);
|
||||
}
|
||||
|
||||
fn probe_report(nvidia: bool, outcomes: &[ProbeOutcome]) -> ProbeReport {
|
||||
let order = auto_order(nvidia);
|
||||
let chosen = choose_from_probe(&order, outcomes);
|
||||
ProbeReport::fresh(order, outcomes.to_vec(), chosen, std::time::Instant::now(), nvidia)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_order_keeps_nvenc_when_nvidia_is_present() {
|
||||
assert_eq!(auto_order(true), vec![Encoder::Nvenc, Encoder::Cpu]);
|
||||
assert_eq!(auto_order(false), vec![Encoder::Cpu]);
|
||||
assert_eq!(legacy_auto(true), Encoder::Nvenc);
|
||||
assert_eq!(legacy_auto(false), Encoder::Cpu);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn auto_falls_back_when_the_first_candidate_fails() {
|
||||
let both = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Fail(ProbeFail::Exit)]);
|
||||
assert_eq!(both.chosen, Encoder::Cpu);
|
||||
let nv = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
|
||||
assert_eq!(nv.chosen, Encoder::Nvenc);
|
||||
let failed = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok]);
|
||||
assert_eq!(failed.chosen, Encoder::Cpu);
|
||||
assert_eq!(resolve_pair(None, None, None, None, true, Some(&nv)).encoder, Encoder::Nvenc);
|
||||
assert_eq!(resolve_pair(None, None, None, None, true, Some(&failed)).encoder, Encoder::Cpu);
|
||||
let cpu = probe_report(false, &[ProbeOutcome::Ok]);
|
||||
assert_eq!(cpu.chosen, Encoder::Cpu);
|
||||
assert_eq!(resolve_pair(None, None, None, None, false, Some(&cpu)).encoder, Encoder::Cpu);
|
||||
let skipped = probe_report(false, &[ProbeOutcome::NotProbed]);
|
||||
assert_eq!(skipped.chosen, Encoder::Cpu);
|
||||
assert_eq!(ProbeOutcome::NotProbed.label(), "not probed (only candidate)");
|
||||
assert!(!ProbeOutcome::NotProbed.ok());
|
||||
assert_eq!(resolve_pair(None, None, None, None, false, Some(&skipped)).encoder, Encoder::Cpu);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_env_and_setting_ignore_the_probe() {
|
||||
let va = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
|
||||
assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, Some(&va)).encoder, Encoder::Nvenc);
|
||||
assert_eq!(resolve_pair(None, Some("cpu"), None, None, true, Some(&va)).encoder, Encoder::Cpu);
|
||||
assert_eq!(resolve_pair(Some("vaapi"), Some("nvenc"), None, None, true, Some(&va)).encoder, Encoder::Vaapi);
|
||||
assert_eq!(resolve_pair(Some("nvenc"), None, None, None, false, Some(&va)).encoder_source, Source::Setting);
|
||||
assert_eq!(resolve_pair(None, Some("cpu"), None, None, false, Some(&va)).encoder_source, Source::Env);
|
||||
assert_eq!(resolve_pair(Some("auto"), Some("vaapi"), None, None, false, None).encoder, Encoder::Vaapi);
|
||||
assert_eq!(resolve_pair(None, None, None, Some("h264"), false, Some(&va)).codec_pref, CodecPref::H264);
|
||||
}
|
||||
|
||||
/// Codec at CONTROL open is `preferred_codec_for` on the session snapshot.
|
||||
/// Auto + CPU uses H.264 when both codecs are negotiated; auto + NVENC keeps H.265.
|
||||
/// Forced codec ignores the encoder. 真彩 does not switch codec (true_color_keeps_codec_and_vaapi_reports_420).
|
||||
#[test]
|
||||
fn auto_codec_follows_the_encoder_chosen_at_session_setup() {
|
||||
use crate::capture_setting::{preferred_codec_for, VideoCodec};
|
||||
|
||||
let cpu_fallback = probe_report(true, &[ProbeOutcome::Fail(ProbeFail::NoIdr), ProbeOutcome::Ok]);
|
||||
let session = resolve_pair(None, None, None, None, true, Some(&cpu_fallback));
|
||||
assert_eq!((session.encoder, session.encoder_source, session.codec_pref), (Encoder::Cpu, Source::Auto, CodecPref::Auto));
|
||||
assert_eq!(preferred_codec_for(true, true, session), VideoCodec::H264);
|
||||
// Not the H.265 an unfinished probe would pick for legacy NVENC.
|
||||
let early_nvenc = resolve_pair(None, None, None, None, true, None);
|
||||
assert_eq!(early_nvenc.encoder, Encoder::Nvenc);
|
||||
assert_eq!(preferred_codec_for(true, true, early_nvenc), VideoCodec::H265);
|
||||
|
||||
let nvenc_ok = probe_report(true, &[ProbeOutcome::Ok, ProbeOutcome::Ok]);
|
||||
let nvenc = resolve_pair(None, None, None, None, true, Some(&nvenc_ok));
|
||||
assert_eq!(nvenc.encoder, Encoder::Nvenc);
|
||||
assert_eq!(preferred_codec_for(true, true, nvenc), VideoCodec::H265);
|
||||
|
||||
let order = auto_order(true);
|
||||
let unprobed = [ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok];
|
||||
let chosen = chosen_after_native(true, &order, &unprobed, choose_from_probe(&order, &unprobed));
|
||||
let report = ProbeReport::fresh(order.clone(), unprobed.to_vec(), chosen, std::time::Instant::now(), true);
|
||||
let native = resolve_pair(None, None, None, None, true, Some(&report));
|
||||
assert_eq!(native.encoder, Encoder::Nvenc);
|
||||
assert_eq!(preferred_codec_for(true, true, native), VideoCodec::H265);
|
||||
|
||||
let forced_h264 = resolve_pair(None, None, Some("h264"), None, true, Some(&nvenc_ok));
|
||||
assert_eq!(forced_h264.encoder, Encoder::Nvenc);
|
||||
assert_eq!(preferred_codec_for(true, true, forced_h264), VideoCodec::H264);
|
||||
let forced_h265 = resolve_pair(None, None, None, Some("h265"), true, Some(&cpu_fallback));
|
||||
assert_eq!(forced_h265.encoder, Encoder::Cpu);
|
||||
assert_eq!(preferred_codec_for(true, true, forced_h265), VideoCodec::H265);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn session_before_probe_uses_legacy_auto() {
|
||||
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
|
||||
clear_probe();
|
||||
assert!(cached_probe().is_none());
|
||||
let early = resolve_pair(None, None, None, None, false, None);
|
||||
assert_eq!((early.encoder, early.encoder_source), (Encoder::Cpu, Source::Auto));
|
||||
assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc);
|
||||
store_probe(probe_report(true, &[ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok]));
|
||||
assert_eq!(cached_probe().unwrap().chosen, Encoder::Cpu);
|
||||
assert_eq!(resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder, Encoder::Cpu);
|
||||
// A snapshot taken before the cache filled stays on the legacy encoder.
|
||||
assert_eq!(early.encoder, Encoder::Cpu);
|
||||
assert_eq!(resolve_pair(None, None, None, None, true, None).encoder, Encoder::Nvenc);
|
||||
clear_probe();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn success_and_not_probed_do_not_expire() {
|
||||
let now = std::time::Instant::now();
|
||||
let later = now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1);
|
||||
let ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true);
|
||||
assert!(ok.expires_at.is_none());
|
||||
assert!(!probe_expired(&ok, later));
|
||||
let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
|
||||
assert!(skipped.expires_at.is_none());
|
||||
assert!(!probe_expired(&skipped, later));
|
||||
let native = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::NativeUnprobed, ProbeOutcome::Ok],
|
||||
Encoder::Nvenc,
|
||||
now,
|
||||
true,
|
||||
);
|
||||
assert!(native.expires_at.is_none(), "native_unprobed is not a recorded process failure");
|
||||
assert!(!probe_expired(&native, later));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hardware_failure_expires_after_ttl() {
|
||||
let now = std::time::Instant::now();
|
||||
let failed = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok],
|
||||
Encoder::Cpu,
|
||||
now,
|
||||
true,
|
||||
);
|
||||
assert!(!probe_expired(&failed, now + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1)));
|
||||
assert!(probe_expired(&failed, now + PROBE_FAILURE_TTL));
|
||||
assert_eq!(failed.chosen, Encoder::Cpu);
|
||||
}
|
||||
|
||||
/// NVENC produced an IDR and CPU failed: the session uses NVENC, so this is
|
||||
/// not the hardware-fallback cache. No TTL, and doctor (which keys off
|
||||
/// `expires_at`) does not append the failure label.
|
||||
#[test]
|
||||
fn nvenc_ok_cpu_fail_does_not_expire() {
|
||||
let now = std::time::Instant::now();
|
||||
let report = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::Ok, ProbeOutcome::Fail(ProbeFail::Exit)],
|
||||
Encoder::Nvenc,
|
||||
now,
|
||||
true,
|
||||
);
|
||||
assert_eq!(report.chosen, Encoder::Nvenc);
|
||||
assert!(report.expires_at.is_none());
|
||||
assert!(!probe_expired(&report, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1)));
|
||||
let cpu_only_fail = ProbeReport::fresh(
|
||||
auto_order(false),
|
||||
vec![ProbeOutcome::Fail(ProbeFail::Exit)],
|
||||
Encoder::Cpu,
|
||||
now,
|
||||
false,
|
||||
);
|
||||
assert!(cpu_only_fail.expires_at.is_none(), "a CPU-only Fail is not a hardware fallback");
|
||||
}
|
||||
|
||||
/// Failed NVENC stays CPU until `PROBE_FAILURE_TTL`. After that a desktop connection
|
||||
/// asks for one background re-probe (`probe_needs_run`, what `warm_auto_probe` checks)
|
||||
/// and still selects the cached CPU encoder. A successful re-probe selects NVENC and
|
||||
/// does not expire. A second failure restarts the TTL.
|
||||
#[test]
|
||||
fn failure_then_reprobe_success_selects_nvenc() {
|
||||
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
|
||||
clear_probe();
|
||||
let t0 = std::time::Instant::now();
|
||||
let failed = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok],
|
||||
Encoder::Cpu,
|
||||
t0,
|
||||
true,
|
||||
);
|
||||
store_probe(failed);
|
||||
let before = t0 + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1);
|
||||
assert!(!probe_needs_run(before, true), "no re-probe before the failure expires");
|
||||
assert_eq!(
|
||||
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
|
||||
Encoder::Cpu
|
||||
);
|
||||
let after = t0 + PROBE_FAILURE_TTL;
|
||||
assert!(probe_expired(cached_probe().as_ref().unwrap(), after));
|
||||
assert!(probe_needs_run(after, true), "desktop connection starts one background re-probe");
|
||||
assert_eq!(
|
||||
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
|
||||
Encoder::Cpu,
|
||||
"the connection that notices expiry still uses the cached encoder"
|
||||
);
|
||||
let retried = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::Ok, ProbeOutcome::Ok],
|
||||
Encoder::Nvenc,
|
||||
after,
|
||||
true,
|
||||
);
|
||||
store_probe(retried);
|
||||
assert_eq!(
|
||||
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
|
||||
Encoder::Nvenc
|
||||
);
|
||||
assert!(!probe_needs_run(after + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), true));
|
||||
let failed_again = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::Fail(ProbeFail::Timeout), ProbeOutcome::Ok],
|
||||
Encoder::Cpu,
|
||||
after,
|
||||
true,
|
||||
);
|
||||
store_probe(failed_again);
|
||||
assert!(!probe_needs_run(after + PROBE_FAILURE_TTL - std::time::Duration::from_secs(1), true));
|
||||
assert!(probe_needs_run(after + PROBE_FAILURE_TTL, true));
|
||||
clear_probe();
|
||||
}
|
||||
|
||||
/// A CPU-only `NotProbed` report does not expire by time. When NVIDIA appears
|
||||
/// (module or device after the user service started), the next desktop
|
||||
/// connection treats it as stale and `probe_needs_run` asks for one background
|
||||
/// re-probe. The inverse (NVENC success, device gone) is stale the same way.
|
||||
/// The connection that notices still selects the cached encoder.
|
||||
#[test]
|
||||
fn nvidia_presence_change_makes_probe_stale() {
|
||||
let now = std::time::Instant::now();
|
||||
let cpu_only = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
|
||||
assert!(!probe_stale(&cpu_only, now + PROBE_FAILURE_TTL + std::time::Duration::from_secs(1), false));
|
||||
assert!(probe_stale(&cpu_only, now, true), "NVIDIA appeared after the CPU-only skip");
|
||||
let nvenc_ok = ProbeReport::fresh(auto_order(true), vec![ProbeOutcome::Ok, ProbeOutcome::Ok], Encoder::Nvenc, now, true);
|
||||
assert!(!probe_stale(&nvenc_ok, now, true));
|
||||
assert!(probe_stale(&nvenc_ok, now, false), "NVIDIA gone after a successful NVENC probe");
|
||||
|
||||
let _guard = PROBE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner());
|
||||
clear_probe();
|
||||
store_probe(cpu_only);
|
||||
assert!(!probe_needs_run(now, false));
|
||||
assert!(probe_needs_run(now, true));
|
||||
assert_eq!(
|
||||
resolve_pair(None, None, None, None, true, cached_probe().as_ref()).encoder,
|
||||
Encoder::Cpu,
|
||||
"the connection that notices the presence change still uses the cached encoder"
|
||||
);
|
||||
clear_probe();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reprobe_reason_follows_previous_state() {
|
||||
let now = std::time::Instant::now();
|
||||
assert_eq!(reprobe_reason(None, false), None);
|
||||
assert_eq!(reprobe_reason(None, true), None);
|
||||
|
||||
let failed = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::Fail(ProbeFail::Exit), ProbeOutcome::Ok],
|
||||
Encoder::Cpu,
|
||||
now,
|
||||
true,
|
||||
);
|
||||
assert!(failed.expires_at.is_some());
|
||||
assert_eq!(reprobe_reason(Some(&failed), true), Some("retry after failure"));
|
||||
assert_eq!(reprobe_reason(Some(&failed), false), Some("retry after failure"));
|
||||
|
||||
let nvenc_ok = ProbeReport::fresh(
|
||||
auto_order(true),
|
||||
vec![ProbeOutcome::Ok, ProbeOutcome::Ok],
|
||||
Encoder::Nvenc,
|
||||
now,
|
||||
true,
|
||||
);
|
||||
assert_eq!(reprobe_reason(Some(&nvenc_ok), true), None);
|
||||
assert_eq!(reprobe_reason(Some(&nvenc_ok), false), Some("NVIDIA availability changed"));
|
||||
|
||||
let skipped = ProbeReport::fresh(auto_order(false), vec![ProbeOutcome::NotProbed], Encoder::Cpu, now, false);
|
||||
assert_eq!(reprobe_reason(Some(&skipped), false), None);
|
||||
assert_eq!(reprobe_reason(Some(&skipped), true), Some("NVIDIA availability changed"));
|
||||
assert_ne!(reprobe_reason(Some(&nvenc_ok), false), Some("retry after failure"));
|
||||
assert_ne!(reprobe_reason(Some(&skipped), true), Some("retry after failure"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn warm_probe_only_when_encoder_source_is_auto() {
|
||||
assert!(should_warm_auto_probe(Source::Auto));
|
||||
assert!(!should_warm_auto_probe(Source::Setting));
|
||||
assert!(!should_warm_auto_probe(Source::Env));
|
||||
assert_eq!(resolve_pair(Some("cpu"), None, None, None, true, None).encoder_source, Source::Setting);
|
||||
assert_eq!(resolve_pair(None, Some("nvenc"), None, None, false, None).encoder_source, Source::Env);
|
||||
assert_eq!(resolve_pair(None, Some("auto"), None, None, false, None).encoder_source, Source::Auto);
|
||||
}
|
||||
}
|
||||
@@ -76,7 +76,7 @@ async fn exercise(fail_wake: usize, fail_capture: bool) {
|
||||
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 selection = crate::video_select::resolve_pair(Some("cpu"), None, Some("h264"), None, false, None);
|
||||
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 {
|
||||
|
||||
Reference in new issue
Block a user