fix(viewer): prevent compressed-frame queue overflow at high input rates (#143)

This commit is contained in:
AZsaber authored and GitHub committed 2026-11-01 21:11:07 +08:00
1 parent 33861082dc
commit 1bdc0eb910
5 files changed
+193 -26

No files matched your search

+135 -14
View File
@@ -3,7 +3,7 @@ use std::sync::{Arc, atomic::{AtomicBool,AtomicU32,Ordering}};
#[derive(Clone)]
pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<AtomicBool>, pub reset:Arc<AtomicBool>, pub ssrc:Arc<AtomicU32> }
impl Default for Desktop {
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
fn default()->Self {Self{units:Latest::new(8),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
}
/// `content` is the source picture size inside the (possibly padded) RGB canvas; None = full frame.
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8>, pub content:Option<(u32,u32)> }
@@ -51,12 +51,15 @@ impl KeyGate {
} else {false}
}
}
/// Shows the newest frame a decoder finished between access units.
pub fn drain(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink)->Result<(),String> {
if let Some(frame)=decoder.poll().pop() {STATS[1].fetch_add(1,Ordering::Relaxed);sink.present(&frame)?;}
fn present(sink:&mut dyn FrameSink,frame:&Frame)->Result<(),String> {
sink.present(frame)?;
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
}}
Ok(())
}
pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Result<(),String> {
fn decode(decoder:&mut dyn Decoder,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Vec<Frame> {
let units=STATS[0].fetch_add(1,Ordering::Relaxed)+1;
// A later session can join a clean stream with no IDR in flight (#124): keep asking until a frame shows.
if wants_key_frame(units,STATS[1].load(Ordering::Relaxed)) {
@@ -68,16 +71,33 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
use std::io::Write; if let Ok(mut f)=std::fs::OpenOptions::new().create(true).append(true).open(path){let _=f.write_all(au);}
}}
match decoder.decode(au) {
Ok(frames)=>{for frame in frames {
sink.present(&frame)?;
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
}}
}Ok(())},
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Ok(())},
Ok(frames)=>frames,
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Vec::new()},
}
}
/// Feed reference-dependent units in FIFO order, but present only the newest decoded picture.
pub fn pump(desktop:&Desktop,decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,gate:&mut KeyGate)->Result<Option<super::media::Codec>,String> {
let started=std::time::Instant::now();
pump_with_elapsed(desktop,decoder,sink,gate,||started.elapsed())
}
fn pump_with_elapsed(desktop:&Desktop,decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,gate:&mut KeyGate,mut elapsed:impl FnMut()->std::time::Duration)->Result<Option<super::media::Codec>,String> {
let mut newest=None;let mut codec=None;
for _ in 0..8 {
let Some(au)=desktop.units.pop() else {break};
if desktop.reset.swap(false,Ordering::AcqRel) {decoder.reset();gate.arm();}
if !gate.admit(au.codec,&au.data) {desktop.pli.store(true,Ordering::Release);}
else {
decoder.set_codec(au.codec)?;codec=Some(au.codec);
if let Some(frame)=decode(decoder,&au.data,au.codec,&desktop.pli).pop() {newest=Some(frame);}
}
// A soft budget between calls: an in-progress decoder call cannot be interrupted.
if elapsed()>=std::time::Duration::from_millis(4) {break}
}
// Asynchronous decoders may finish a picture even when no new input has arrived.
if let Some(frame)=decoder.poll().pop() {newest=Some(frame);}
if let Some(frame)=newest {present(sink,&frame)?;}
Ok(codec)
}
#[cfg(test)] mod tests {
#[test] fn key_frames_by_nal_type(){
use crate::viewer::media::Codec;
@@ -106,5 +126,106 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
assert_eq!((1..=90).filter(|&n|wants_key_frame(n,0)).count(),3);
assert!(!(1..=90).any(|n|wants_key_frame(n,1)));
}
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);}
#[test] fn decode_error_requests_pli_and_recovers(){
let desktop=Desktop::default();let mut d=Mock(true);let mut s=Sink(0);let mut gate=KeyGate::new();
enqueue(&desktop,unit(0,false));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert!(desktop.pli.load(Ordering::Acquire));assert_eq!(s.0,0);
enqueue(&desktop,unit(1,false));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,1);
}
use crate::viewer::media::{AccessUnit,Codec};
use std::time::Duration;
fn unit(id:u32,key:bool)->AccessUnit {
let mut data=vec![0,0,0,1,if key {0x65}else{0x41},0b1001_1000];
data.extend_from_slice(&id.to_le_bytes());AccessUnit{codec:Codec::H264,data}
}
fn picture(id:u32)->Frame {Frame{width:1,height:1,rgb:id.to_le_bytes()[..3].to_vec(),content:None}}
#[derive(Default)]
struct BatchDecoder {seen:Vec<u32>,resets:usize,pending:Vec<Frame>,extra_picture:bool}
impl Decoder for BatchDecoder {
fn set_codec(&mut self,_:Codec)->Result<(),String>{Ok(())}
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String>{
let id=u32::from_le_bytes(au[6..].try_into().unwrap());self.seen.push(id);
let mut frames=vec![picture(id)];if self.extra_picture {frames.push(picture(id+100));}Ok(frames)
}
fn reset(&mut self){self.resets+=1;self.pending.clear();}
fn poll(&mut self)->Vec<Frame>{std::mem::take(&mut self.pending)}
}
#[derive(Default)]
struct Pictures(Vec<u32>);
impl FrameSink for Pictures {
fn present(&mut self,frame:&Frame)->Result<(),String>{assert_eq!(frame.rgb.len(),3);self.0.push(u32::from_le_bytes([frame.rgb[0],frame.rgb[1],frame.rgb[2],0]));Ok(())}
}
// Match the RTP reader's overflow signal without a network or wall-clock sleeps.
fn enqueue(desktop:&Desktop,au:AccessUnit)->bool {
let dropped=desktop.units.push(au);
if dropped {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}
dropped
}
#[test] fn one_unit_per_tick_overflows_even_with_a_larger_queue(){
for capacity in [3,8] {
let q=Latest::new(capacity);let mut arrived=0;let mut dropped=0;
// 1,000 ticks at 125 Hz = 8 seconds; exactly 1,152 units arrive at 144 Hz.
for tick in 1..=1000 {
let due=tick*144/125;
while arrived<due {dropped+=usize::from(q.push(arrived));arrived+=1;}
assert!(q.pop().is_some());
}
assert_eq!(arrived,1152);assert_eq!(dropped,152-(capacity-1));
}
}
#[test] fn batches_keep_up_with_144_units_per_second_in_fifo_order(){
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();let mut arrived=0;
for tick in 1..=1000 {
let due=tick*144/125;
while arrived<due {assert!(!enqueue(&desktop,unit(arrived,false)));arrived+=1;}
let before=s.0.len();
assert_eq!(pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap(),Some(Codec::H264));
assert_eq!(s.0.len(),before+1);assert_eq!(s.0.last(),Some(&(due-1)));
}
assert_eq!(arrived,1152);assert_eq!(d.seen,(0..1152).collect::<Vec<_>>());
assert_eq!(d.resets,0);assert!(desktop.units.pop().is_none());assert!(!desktop.reset.load(Ordering::Acquire));
}
#[test] fn batch_presents_only_the_latest_picture_and_polls_when_idle(){
let desktop=Desktop::default();let mut d=BatchDecoder{extra_picture:true,..Default::default()};let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..3 {assert!(!enqueue(&desktop,unit(id,false)));}
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,vec![0,1,2]);assert_eq!(s.0,vec![102]);
d.pending=vec![picture(103),picture(104)];
assert_eq!(pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap(),None);
assert_eq!(s.0,vec![102,104]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,vec![102,104]);
enqueue(&desktop,unit(105,false));d.pending=vec![picture(206)];
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,vec![102,104,206]);
}
#[test] fn actual_queue_loss_still_resets_and_waits_for_a_key_frame(){
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..8 {assert!(!enqueue(&desktop,unit(id,false)));}
assert!(enqueue(&desktop,unit(8,false)));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.resets,1);assert!(d.seen.is_empty());assert!(s.0.is_empty());assert!(desktop.pli.load(Ordering::Acquire));
enqueue(&desktop,unit(9,false));enqueue(&desktop,unit(10,true));enqueue(&desktop,unit(11,false));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.resets,1);assert_eq!(d.seen,vec![10,11]);assert_eq!(s.0,vec![11]);
}
#[test] fn batch_count_limit_leaves_remaining_units_for_the_next_tick(){
let desktop=Desktop{units:Latest::new(12),..Default::default()};let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..12 {assert!(!enqueue(&desktop,unit(id,false)));}
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,(0..8).collect::<Vec<_>>());assert_eq!(s.0,vec![7]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,(0..12).collect::<Vec<_>>());assert_eq!(s.0,vec![7,11]);
}
#[test] fn elapsed_budget_is_checked_between_calls_and_preserves_the_queue(){
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..4 {enqueue(&desktop,unit(id,false));}
let mut times=[Duration::from_millis(3),Duration::from_millis(4)].into_iter();
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||times.next().unwrap()).unwrap();
assert_eq!(d.seen,vec![0,1]);assert_eq!(s.0,vec![1]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::from_millis(20)).unwrap();
assert_eq!(d.seen,vec![0,1,2]);assert_eq!(s.0,vec![1,2]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,vec![0,1,2,3]);assert_eq!(s.0,vec![1,2,3]);
}
}
+3 -12
View File
@@ -551,18 +551,9 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
else {input.release_all();}
if quit{return Ok(())}
// At most one AU per iteration keeps local event polling responsive.
if let Some(au)=session.peer.desktop.units.pop(){
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();key_gate.arm();}
if !key_gate.admit(au.codec,&au.data) {session.peer.desktop.pli.store(true,std::sync::atomic::Ordering::Release);super::desktop::drain(decoder,window)?;}
else {
decoder.set_codec(au.codec)?;
codec_name=if au.codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;
}}
// A picture can finish after its access unit was written; show it without waiting
// for the next one (a single keystroke may change the remote screen only once).
else {super::desktop::drain(decoder,window)?;}
if let Some(codec)=super::desktop::pump(&session.peer.desktop,decoder,window,&mut key_gate)? {
codec_name=if codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
}
}
}}
}.await;