Files
uu-remote-linux/src/viewer/audio.rs
T
809ce1697d Add the experimental native viewer (uuremote-viewer) (#36)
* Add the experimental native viewer (uuremote-viewer)

A Linux viewer/controller for UU Remote hosts, built separately with
--features native-viewer,viewer-sdl; the host build and behaviour are
unchanged.

- Cloud join by device and remote assistance by share ID + code (code
  via stdin only), WebRTC offer side, SDL desktop window with ffmpeg CLI
  H.264 decoding, Opus sound, keyboard/mouse, view-only mode, text
  clipboard on TEXT_DATA_CHANNEL.
- Tools: file browser/transfer (zero- and one-based download blocks),
  terminal and terminal session list, port mapping (127.0.0.1 only),
  reboot/shutdown; tools reuse the desktop peer while one is open.
- GTK launcher with device list and tool windows.
- CI builds and tests the viewer; release tarballs include it.

Logs carry field numbers, sizes and states only.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

* ci: install the ffmpeg CLI for the viewer audio tests

Co-Authored-By: Claude Opus 5.5 <[email protected]>

---------

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-17 15:41:20 +08:00

171 lines
10 KiB
Rust

use super::media::Latest;
const PACKETS:usize=12;
const MAX_PACKET:usize=8192;
#[derive(Clone)]
pub struct Packet { seq:u16, data:Vec<u8> }
#[derive(Clone)]
pub struct Audio { packets:Latest<Packet>, enabled:bool }
impl Default for Audio {
fn default()->Self {Self{packets:Latest::new(PACKETS),enabled:std::env::var("UU_VIEWER_AUDIO").map_or(true,|v|v!="0")}}
}
impl Audio {
#[cfg(test)] pub fn pop(&self)->Option<Vec<u8>> {self.packets.pop().map(|p|p.data)}
pub fn push(&self,seq:u16,data:&[u8]) {
if self.enabled && data.len()<=MAX_PACKET && samples(data).is_some() {self.packets.push(Packet{seq,data:data.to_vec()});}
}
}
fn samples(data:&[u8])->Option<u64> {
let toc=*data.first()?;
let frame=if toc&0x80!=0 {120u64<<(toc>>3&3)} else if toc&0x60==0x60 {if toc&8!=0 {960}else{480}} else {match toc>>3&3 {3=>2880,n=>480u64<<n}};
let count=match toc&3 {0=>1,1|2=>2,_=>u64::from(*data.get(1)?&63)};
let total=frame*count;(count>0 && total<=5760).then_some(total)
}
// One complete packet per page; zero pre-skip because RTP has no encoder pre-skip header.
#[derive(Default)]
struct Ogg { sequence:u32, granule:u64, last:Option<u16> }
impl Ogg {
fn page(&mut self,payload:&[u8],flags:u8)->Vec<u8> {
let mut page=b"OggS\0".to_vec();page.push(flags);page.extend(self.granule.to_le_bytes());
page.extend(1u32.to_le_bytes());page.extend(self.sequence.to_le_bytes());self.sequence=self.sequence.wrapping_add(1);
page.extend([0;4]);page.push((payload.len()/255+1) as u8);
page.extend(std::iter::repeat(255).take(payload.len()/255));page.push((payload.len()%255) as u8);page.extend(payload);
let mut crc=0u32;
for byte in &page {crc^=u32::from(*byte)<<24;for _ in 0..8 {crc=if crc&0x80000000!=0 {(crc<<1)^0x04c11db7}else{crc<<1};}}
page[22..26].copy_from_slice(&crc.to_le_bytes());page
}
fn headers(&mut self)->Vec<u8> {
let mut head=b"OpusHead\x01\x02\0\0".to_vec();head.extend(48000u32.to_le_bytes());head.extend([0,0,0]);
let mut out=self.page(&head,2);let mut tags=b"OpusTags".to_vec();tags.extend([0;8]);out.extend(self.page(&tags,0));out
}
fn packet(&mut self,packet:Packet)->Option<Vec<u8>> {
if self.last.is_some_and(|last|{let delta=packet.seq.wrapping_sub(last);delta==0 || delta>=0x8000}) {return None}
self.granule+=samples(&packet.data)?;self.last=Some(packet.seq);Some(self.page(&packet.data,0))
}
}
#[cfg(feature="viewer-sdl")]
mod playback {
use super::*;
use tokio::{io::{AsyncReadExt,AsyncWriteExt},process::{Child,Command},task::JoinHandle};
use std::{process::Stdio,time::Duration};
const PCM_SAMPLES:usize=1920;
const PCM_BYTES:usize=PCM_SAMPLES*2;
const SDL_BYTES:u32=48000*2*2/10;
struct Decoder { child:Option<Child>, tasks:Vec<JoinHandle<()>>, pcm:Latest<Vec<i16>> }
impl Decoder {
fn new(audio:Audio)->Result<Self,String> {
let mut child=Command::new(std::env::var_os("UU_VIEWER_FFMPEG").unwrap_or_else(||"ffmpeg".into()))
.args(["-hide_banner","-loglevel","error","-nostdin","-threads","1","-probesize","32","-analyzeduration","0",
"-f","ogg","-i","pipe:0","-vn","-ac","2","-ar","48000","-c:a","pcm_s16le","-f","s16le","-flush_packets","1","pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().map_err(|_|"Audio decoder start failed")?;
let mut input=child.stdin.take().ok_or("Audio decoder stdin missing")?;
let mut output=child.stdout.take().ok_or("Audio decoder stdout missing")?;
let pcm=Latest::new(PACKETS);let decoded=pcm.clone();
let writer=tokio::spawn(async move {
let mut ogg=Ogg::default();
let result:std::io::Result<()>=async {
input.write_all(&ogg.headers()).await?;
let mut tick=tokio::time::interval(Duration::from_millis(4));
loop {
tick.tick().await;
while let Some(packet)=audio.packets.pop() {if let Some(page)=ogg.packet(packet) {
tokio::time::timeout(Duration::from_secs(1),input.write_all(&page)).await??;
}}
}
}.await;
if result.is_err() {log::warn!("Viewer audio decoder input stopped");}
});
let reader=tokio::spawn(async move {
let mut bytes=[0u8;PCM_BYTES];
while output.read_exact(&mut bytes).await.is_ok() {
decoded.push(bytes.chunks_exact(2).map(|b|i16::from_le_bytes([b[0],b[1]])).collect());
}
});
Ok(Self{child:Some(child),tasks:vec![writer,reader],pcm})
}
fn alive(&mut self)->bool {self.child.as_mut().is_some_and(|child|matches!(child.try_wait(),Ok(None))) && self.tasks.iter().all(|t|!t.is_finished())}
}
impl Drop for Decoder {
fn drop(&mut self) {
for task in &self.tasks {task.abort();}
if let Some(mut child)=self.child.take() {let _=child.start_kill();tokio::spawn(async move {let _=child.wait().await;});}
}
}
pub struct Playback { queue:sdl2::audio::AudioQueue<i16>, decoder:Decoder }
impl Playback {
pub fn new(sdl:&sdl2::Sdl,audio:Audio)->Option<Self> {
if !audio.enabled {return None}
let result=(|| {
let subsystem=sdl.audio()?;
let queue=subsystem.open_queue::<i16,_>(None,&sdl2::audio::AudioSpecDesired{freq:Some(48000),channels:Some(2),samples:Some(960)})?;
let decoder=Decoder::new(audio)?;queue.resume();Ok::<_,String>(Self{queue,decoder})
})();
match result {Ok(p)=>Some(p),Err(_)=>{log::warn!("Viewer audio playback unavailable");None}}
}
pub fn pump(&mut self)->Result<(),String> {
if !self.decoder.alive() {return Err("Audio decoder stopped".into())}
while let Some(samples)=self.decoder.pcm.pop() {
if self.queue.size()+samples.len() as u32*2>SDL_BYTES {self.queue.clear();}
self.queue.queue_audio(&samples).map_err(|_|"Audio queue failed")?;
}Ok(())
}
}
#[cfg(test)] mod tests {
use super::*;
#[tokio::test] async fn sdl_dummy_queue_is_bounded_and_audio_can_be_disabled() {
if std::env::var_os("UU_VIEWER_AUDIO_TEST_CHILD").is_none() {
let output=std::process::Command::new(std::env::current_exe().unwrap()).args(["--exact","viewer::audio::playback::tests::sdl_dummy_queue_is_bounded_and_audio_can_be_disabled","--test-threads=1"])
.env("SDL_AUDIODRIVER","dummy").env("UU_VIEWER_AUDIO_TEST_CHILD","1").output().unwrap();
assert!(output.status.success(),"{}",String::from_utf8_lossy(&output.stdout));return
}
let sdl=sdl2::init().unwrap();
assert!(Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:false}).is_none());
let mut playback=Playback::new(&sdl,Audio{packets:Latest::new(PACKETS),enabled:true}).unwrap();playback.queue.pause();
for value in 0..100 {playback.decoder.pcm.push(vec![value;PCM_SAMPLES]);}
playback.pump().unwrap();assert!(playback.queue.size()>0 && playback.queue.size()<=SDL_BYTES);
assert!(playback.decoder.pcm.pop().is_none());
}
#[tokio::test] async fn ffmpeg_streams_pcm_before_eof_and_is_reaped() {
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};let mut decoder=Decoder::new(audio.clone()).unwrap();
let id=decoder.child.as_ref().unwrap().id().unwrap();
tokio::time::timeout(Duration::from_secs(5),async {
for seq in 0..250 {audio.push(seq,&[0xf8,0xff,0xfe]);tokio::time::sleep(Duration::from_millis(8)).await;
if let Some(pcm)=decoder.pcm.pop() {assert_eq!(pcm.len(),PCM_SAMPLES);assert!(decoder.alive());return}
}panic!("No PCM before EOF");
}).await.unwrap();
drop(decoder);
tokio::time::timeout(Duration::from_secs(2),async {while unsafe{libc::kill(id as i32,0)}==0 {tokio::time::sleep(Duration::from_millis(10)).await;}}).await.unwrap();
}
}
}
#[cfg(feature="viewer-sdl")] pub use playback::Playback;
#[cfg(test)] mod tests {
use super::*;
#[test] fn duration_bounds_and_latest_packets() {
assert_eq!(samples(&[0xf8,0xff,0xfe]),Some(960));assert_eq!(samples(&[0x98]),Some(960));
assert_eq!(samples(&[0x18]),Some(2880));assert_eq!(samples(&[0x83,48]),Some(5760));
assert_eq!(samples(&[0x83,49]),None);assert_eq!(samples(&[3,0]),None);assert_eq!(samples(&[]),None);
let audio=Audio{packets:Latest::new(PACKETS),enabled:true};
for seq in 0..1000 {audio.push(seq,&[0xf8,0xff,0xfe]);}
audio.push(1000,&vec![0;MAX_PACKET+1]);audio.push(1000,&[]);
for seq in 988..1000 {assert_eq!(audio.packets.pop().unwrap().seq,seq);}assert!(audio.packets.pop().is_none());
let disabled=Audio{enabled:false,..audio};disabled.push(0,&[0xf8,0xff,0xfe]);assert!(disabled.packets.pop().is_none());
}
#[test] fn ogg_headers_crc_lacing_and_sequence_wrap() {
let mut ogg=Ogg::default();let headers=ogg.headers();assert_eq!(&headers[..4],b"OggS");assert_eq!(&headers[28..36],b"OpusHead");
let page=ogg.page(&vec![0;255],0);assert_eq!(&page[27..29],&[255,0]);
let mut stream=headers;stream.extend(&page);
let (mut reader,head)=webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream.clone()),true).unwrap();
assert_eq!(head.channels,2);assert_eq!(head.sample_rate,48000);
assert!(reader.parse_next_page().unwrap().0.starts_with(b"OpusTags"));
assert_eq!(reader.parse_next_page().unwrap().0.len(),255);
stream[28]^=1;assert!(webrtc::media::io::ogg_reader::OggReader::new(std::io::Cursor::new(stream),true).is_err());
let packet=|seq|Packet{seq,data:vec![0xf8,0xff,0xfe]};
assert!(ogg.packet(packet(65535)).is_some());assert!(ogg.packet(packet(0)).is_some());
assert!(ogg.packet(packet(0)).is_none());assert!(ogg.packet(packet(65534)).is_none());assert_eq!(ogg.granule,1920);
}
}