Add diagnostic logging (no behaviour change) to distinguish, from one instrumented Windows test call, whether an auto-detected call records nothing because the wrong process tree was targeted, packets arrive but are flagged silent, or process loopback failed to start and the fallback hit the wrong device: - Log one line on every successful WASAPI stream open (initial and reopen): endpoint description (process tree pid + exe name for loopback, friendly name/id/role for device endpoints), rate and channels. - output_source_with_fallback: Info line when the primary target starts OK; the existing fallback Warn line now also names DefaultRender explicitly. - New CaptureStats (crates/audio/src/stats.rs), shared by the Windows and Linux capture loops: counts packets, frames, packets flagged silent, and the peak absolute sample value, reported every 10 s and once more when a stream stops. Plain counters updated inline on the audio thread; no locks, no extra threads. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
219 lines
7.1 KiB
Rust
219 lines
7.1 KiB
Rust
//! Output capture that falls back from per-process to device loopback.
|
|
//!
|
|
//! Application loopback (`OutputTarget::Process`) needs Windows 10 2004+ and
|
|
//! a live process; if it cannot be opened, the call is still worth recording
|
|
//! from the default output. [`crate::Recorder`] keeps a failed track running
|
|
//! as silence instead of retrying, so the retry happens here, inside
|
|
//! `start`.
|
|
|
|
use std::sync::{Arc, Mutex, PoisonError};
|
|
|
|
use recorder_core::capture::{
|
|
CaptureError, CaptureSource, DataCallback, OutputTarget, StreamFormat,
|
|
};
|
|
|
|
/// Creates the platform source for one output target.
|
|
pub(crate) type Factory = fn(OutputTarget) -> Box<dyn CaptureSource>;
|
|
|
|
/// Tries `target`, and if that is a `Process` target that fails to start,
|
|
/// `DefaultRender`. `stop` and `failure` act on whichever source started.
|
|
pub(crate) struct FallbackSource {
|
|
target: OutputTarget,
|
|
factory: Factory,
|
|
active: Option<Box<dyn CaptureSource>>,
|
|
}
|
|
|
|
impl FallbackSource {
|
|
pub(crate) fn new(target: OutputTarget, factory: Factory) -> Self {
|
|
Self {
|
|
target,
|
|
factory,
|
|
active: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl CaptureSource for FallbackSource {
|
|
fn start(&mut self, on_data: DataCallback) -> Result<StreamFormat, CaptureError> {
|
|
self.stop();
|
|
// A failed start consumes the callback it was given, so each attempt
|
|
// gets a forwarder to the one shared callback.
|
|
let on_data = Arc::new(Mutex::new(on_data));
|
|
let forward = |on_data: &Arc<Mutex<DataCallback>>| -> DataCallback {
|
|
let on_data = Arc::clone(on_data);
|
|
Box::new(move |samples| {
|
|
(on_data.lock().unwrap_or_else(PoisonError::into_inner))(samples)
|
|
})
|
|
};
|
|
|
|
let mut source = (self.factory)(self.target.clone());
|
|
let format = match source.start(forward(&on_data)) {
|
|
Ok(format) => {
|
|
log::info!("output target {:?} started", self.target);
|
|
format
|
|
}
|
|
Err(err) => {
|
|
let OutputTarget::Process { root_pid } = self.target else {
|
|
return Err(err);
|
|
};
|
|
log::warn!(
|
|
"process loopback for pid {root_pid} failed ({err}), \
|
|
falling back to DefaultRender"
|
|
);
|
|
source = (self.factory)(OutputTarget::DefaultRender);
|
|
source.start(forward(&on_data))?
|
|
}
|
|
};
|
|
self.active = Some(source);
|
|
Ok(format)
|
|
}
|
|
|
|
fn stop(&mut self) {
|
|
if let Some(mut source) = self.active.take() {
|
|
source.stop();
|
|
}
|
|
}
|
|
|
|
fn failure(&self) -> Option<String> {
|
|
self.active.as_ref().and_then(|source| source.failure())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
const FORMAT: StreamFormat = StreamFormat {
|
|
rate: 48_000,
|
|
channels: 2,
|
|
};
|
|
|
|
/// Per-test record of what the fake sources saw. Tests run in parallel,
|
|
/// so each test gets its own log via a thread-local.
|
|
#[derive(Default)]
|
|
struct Log {
|
|
started: Vec<OutputTarget>,
|
|
stopped: Vec<OutputTarget>,
|
|
delivered: Vec<f32>,
|
|
}
|
|
|
|
thread_local! {
|
|
static LOG: Arc<Mutex<Log>> = Arc::new(Mutex::new(Log::default()));
|
|
}
|
|
|
|
fn log() -> Arc<Mutex<Log>> {
|
|
LOG.with(Arc::clone)
|
|
}
|
|
|
|
/// Fails to start for `Process` targets whose pid is 0 and for
|
|
/// `Device("broken")`; otherwise delivers one sample (the call count)
|
|
/// synchronously from `start` and reports a failure for
|
|
/// `Device("dying")`.
|
|
struct FakeOutput {
|
|
target: OutputTarget,
|
|
log: Arc<Mutex<Log>>,
|
|
started: bool,
|
|
}
|
|
|
|
fn fake(target: OutputTarget) -> Box<dyn CaptureSource> {
|
|
Box::new(FakeOutput {
|
|
target,
|
|
log: log(),
|
|
started: false,
|
|
})
|
|
}
|
|
|
|
impl CaptureSource for FakeOutput {
|
|
fn start(&mut self, mut on_data: DataCallback) -> Result<StreamFormat, CaptureError> {
|
|
self.log.lock().unwrap().started.push(self.target.clone());
|
|
match &self.target {
|
|
OutputTarget::Process { root_pid: 0 } => {
|
|
return Err(CaptureError::Backend("no such process".into()))
|
|
}
|
|
OutputTarget::Device(id) if id == "broken" => {
|
|
return Err(CaptureError::DeviceNotFound(id.clone()))
|
|
}
|
|
_ => {}
|
|
}
|
|
self.started = true;
|
|
on_data(&[1.0]);
|
|
Ok(FORMAT)
|
|
}
|
|
|
|
fn stop(&mut self) {
|
|
if std::mem::take(&mut self.started) {
|
|
self.log.lock().unwrap().stopped.push(self.target.clone());
|
|
}
|
|
}
|
|
|
|
fn failure(&self) -> Option<String> {
|
|
(self.started && self.target == OutputTarget::Device("dying".into()))
|
|
.then(|| "device lost".to_string())
|
|
}
|
|
}
|
|
|
|
fn collecting_callback() -> DataCallback {
|
|
let log = log();
|
|
Box::new(move |samples| log.lock().unwrap().delivered.extend_from_slice(samples))
|
|
}
|
|
|
|
#[test]
|
|
fn a_working_process_target_is_used_as_is() {
|
|
let mut source = FallbackSource::new(OutputTarget::Process { root_pid: 42 }, fake);
|
|
assert_eq!(source.start(collecting_callback()).unwrap(), FORMAT);
|
|
source.stop();
|
|
|
|
let log = log();
|
|
let log = log.lock().unwrap();
|
|
assert_eq!(log.started, vec![OutputTarget::Process { root_pid: 42 }]);
|
|
assert_eq!(log.stopped, vec![OutputTarget::Process { root_pid: 42 }]);
|
|
assert_eq!(log.delivered, vec![1.0]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_failing_process_target_falls_back_to_default_render() {
|
|
let mut source = FallbackSource::new(OutputTarget::Process { root_pid: 0 }, fake);
|
|
assert_eq!(source.start(collecting_callback()).unwrap(), FORMAT);
|
|
assert_eq!(source.failure(), None);
|
|
source.stop();
|
|
|
|
let log = log();
|
|
let log = log.lock().unwrap();
|
|
assert_eq!(
|
|
log.started,
|
|
vec![
|
|
OutputTarget::Process { root_pid: 0 },
|
|
OutputTarget::DefaultRender
|
|
]
|
|
);
|
|
assert_eq!(log.stopped, vec![OutputTarget::DefaultRender]);
|
|
// The callback survives the failed first attempt.
|
|
assert_eq!(log.delivered, vec![1.0]);
|
|
}
|
|
|
|
#[test]
|
|
fn other_targets_do_not_fall_back() {
|
|
let mut source = FallbackSource::new(OutputTarget::Device("broken".into()), fake);
|
|
assert!(matches!(
|
|
source.start(collecting_callback()),
|
|
Err(CaptureError::DeviceNotFound(_))
|
|
));
|
|
assert_eq!(
|
|
log().lock().unwrap().started,
|
|
vec![OutputTarget::Device("broken".into())]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn failure_and_stop_act_on_the_started_source() {
|
|
let mut source = FallbackSource::new(OutputTarget::Device("dying".into()), fake);
|
|
assert_eq!(source.failure(), None);
|
|
source.start(collecting_callback()).unwrap();
|
|
assert_eq!(source.failure().as_deref(), Some("device lost"));
|
|
source.stop();
|
|
assert_eq!(source.failure(), None);
|
|
source.stop();
|
|
assert_eq!(log().lock().unwrap().stopped.len(), 1);
|
|
}
|
|
}
|